# 4. Arduino 教程
## 4.1 资料下载
**Arduino资料包含库文件和项目代码，请点击下载才能进行后续的学习！！！！**
点击下载：[Arduino资料](./Arduino.7z)
## 4.2 Windows系统软件下载、安装和开发环境配置
**软件下载**
1\. 打开[Software | Arduino](https://www.arduino.cc/en/software)下载软件，然后选择对应的系统下载，下面以window系统为例。
（)
注意：win11系统点击  此处进行到下载页面 ,无需进行第2步操作。
2\. 然后选择"**只需下载**"，再一次选择"**只需下载**"，就可以看到正在下载的页面。
**软件安装**
1\. 点击此处文件夹 进入到下载中心，双击进行安装。
2\. 选择"**我同意(I)**"，跳转页面后选择"**仅为我安装（Administrator)**",再点击"**下一步**"。
3\. 跳转页面后，点击"**浏览（B）**"，可把软件放到指定位置（请用纯英文路径），点击"**安装**"，安装完成后，点击"**完成**"。
**注：点击”完成“后，如果后面出现弹框，请选择肯定的回复，例如选择”是“、”安装“.**
## 4.3 MAC系统软件下载、安装和开发环境配置
**软件下载**
1\. 打开浏览器，搜索"https://www.arduino.cc/en/software"，选择macOS版本下载，如图：
2\. 之后弹出的界面选择**“JUST DOWNLOAD”**。
3\. 等待下载完成
4\. 双击下载的软件包等待软件运行，正常打开证明软件安装完成。
## 4.4 ESP32环境的安装和配置
1\. 点击“文件”，选择“首选项”。
2\. 点击“”，将ESP32开发板的链接：`https://espressif.github.io/arduino-esp32/package_esp32_index.json` 复制粘贴至文本框中，然后单击 “**确定**”。
3\. 再次单击“确定”。
4\. 点击左边的开发板小图标，打开开发板选项。
5\. 在开发板搜索框中，搜索 “ESP32”，选择“3.2.1”版本，点击安装。
**注：右下角可以看到开发板安装进度，等待几分钟安装完成。安装过程中请保持网络稳定，如安装失败，请重复以上步骤，重新安装开发板即可。**
## 4.5 Arduino IDE设置和工具栏介绍
1\. 点击电脑桌面上的图标，打开Arduino IDE。
2\. 选择正确的Arduino板名称，选择“工具”→“开发板”→“esp32”→“ESP32 Dev Module”。
3\. 选择对应的COM口（安装驱动成功后可看到对应COM口），选择“工具”→“端口”→“对应电脑上的接口（例如图片中的COM3）”
4\. 认识程序工具栏中的符号功能。
A - 用于检查是否存在任何编译错误。
B - 用于将程序上传到Arduino板。
C - 用于从板接收串行数据并将串行数据发送到板的串行监视器。
## 4.6 库文件的添加
**请在此处下载好资料，资料里面包含所需库文件：**
1\. 首先选择 **“项目”**，选择 **“导入库”**，再选择“添加.ZIP库”.
2\. 选择要导入的库，点击 **“打开”**.
3\. 出现“Library installed”证明库导入成功.
## 4.7 上传第一个代码
1\. 开始第一个程序，打开“文件”→“示例”→“01.BASIC”→“Blink”。
2\. 按照前面方法选择开发板和COM口，IDE右下角显示对应板和COM口。
3\. 点击图标开始编译程序。
4\. 点击图标开始上传程序，显示“上传成功”，证明程序上传成功。
程序上传成功，开发板上的LED灯亮一秒钟，灭一秒钟！
## 4.8 Arduino课程
---
### 第一课 Hello World
1.1 项目介绍
对于ESP32的初学者，先从一些简单的开始学习吧！在这个项目中，你只需要一个ESP32主板，USB线和计算机就可以完成“Hello World!”项目。它不仅是ESP32主板和计算机的通信测试，也是ESP32的初级项目。这也是一个入门实验，让你进入计算机的编程世界。
---
1.2 实验组件
|  |  |
| :----------------------: | :-------------------: |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 实验接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**HelloWorld.ino**"。
```c++
/*
* 名称 : Hello World
* 功能 : 输入字母R，串口显示“Hello World”。
* 作者 : http://www.keyes-robot.com/
*/
char val; // 定义变量val
void setup()
{
Serial.begin(9600); // 设置波特率为9600
}
void loop()
{
if (Serial.available() > 0) {
val=Serial.read(); // 读取赋值给"val"的值
if(val=='R') // 检查输入的字母“R”
{ // if so,
Serial.println("Hello World!"); //显示“Hello World !”
}
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**
注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口。 **
单击将代码上传到ESP32主控板。
代码上传成功。
---
1.5 实验结果
代码上传成功后，单击串口监视器图标进入串口监视器，设置波特率为**9600**，接着在文本框输入字母“**R**”，单击“**发送**”，能看到串口监视器打印“**Hello World!**”。
---
1.6 代码说明
| 代码 | 说明 |
| ------------------- | ------------------------------------------------------------ |
| char val | 定义一个变量val |
| Serial.begin(9600) | 设置波特率为9600 |
| Serial.available( ) | 获取串口上可读取的数据的字节数，该数据已经到达并存储在接收缓存（共有64字节）中。Serial.available() > 0表示串口接收到了数据，可以读取。 |
| Serial.read( ) | 读取写入的串行数据。 |
| if( ){ } | 如果“（ ）”里的条件满足，则执行“{ }”里的程序。 |
| Serial.println( ) | 换行输出数据。从串行端口输出数据，跟随一个回车和一个换行符。 |
---
### 第二课 LED
1.1 项目介绍
LED，即发光二极管的简称。由含镓（Ga）、砷（As）、磷（P）、氮（N）等的[化合物](https://baike.baidu.com/item/化合物/1142931)制成。当电子与[空穴](https://baike.baidu.com/item/空穴/3517781)复合时能辐射出可见光，因而可以用来制成发光二极管。在电路及仪器中作为指示灯，或者组成文字或数字显示。砷化镓二极管发红光，磷化镓二极管发绿光，碳化硅二极管发黄光，氮化镓二极管发蓝光。因化学性质又分有机发光二极管OLED和无机发光二极管LED。
为了实验的方便，我们将紫色LED发光二极管做成了一个紫色LED模块。它的控制方法非常简单，只要让LED两端有一定的电压就可以点亮LED。在这个项目中，我们用一个最基本的测试代码来控制LED，亮一秒钟，灭一秒钟，来实现闪烁的效果。你可以改变代码中LED灯亮灭的时间，实现不同的闪烁效果。我们通过编程控制信号端S的高低电平，从而控制LED的亮灭。LED模块信号端S为高电平时LED亮起，S为低电平时LED熄灭。
---
1.2 模块参数
工作电压：DC 3.3-5V
控制信号：数字信号
尺寸：32 x 23.5 x 12 mm
定位孔大小：直径为 4.8 mm
接口：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
这是一个常用的LED模块，它采用F5-白发紫LED（外观白色，显示紫光）元件。同时，模块上自带一个间距为 2.54mm 的 3pin 防反插红色端子。控制时，模块上GND VCC供电后，信号端S为高电平时，模块上LED亮起。
模块兼容各种单片机控制板，如arduino系列单片机。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**blink.ino**"。
**
注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。 **
```c++
/*
* 名称 : Blink
* 功能 : led 闪烁 1s
* 作者 : http://www.keyes-robot.com/
*/
int ledPin = 5; //定义LED引脚连接到GPIO5
void setup() {
pinMode(ledPin, OUTPUT); //设置输出模式
}
void loop() {
digitalWrite(ledPin, HIGH); //输出高电平，打开led
delay(1000);//延时 1000 ms
digitalWrite(ledPin, LOW); //输出低电平，关闭led
delay(1000);//延时 1000 ms
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板。
代码上传成功。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，你会看到模块上的紫色LED一亮一灭，循环闪烁。
---
1.8 代码说明
| 代码 | 说明 |
| -------------------------- | ---------------------------------------------------------- |
| pinMode(ledPin, OUTPUT) | 设置引脚的模式。OUTPUT为输出模式；INPUT为输入模式 |
| digitalWrite(ledPin, HIGH) | 设置引脚的输出电压为高\低电平。HIGH为高电平，LOW为低电平。 |
| delay(1000) | 将程序的执行暂停一段时间,也就是延时。单位是毫秒。 |
---
### 第三课 交通灯模块
1.1 项目介绍
交通灯，也就是马路上十字路口的红绿灯，在我们的日常生活中很常见。交通灯是由红、黄、绿三种颜色组成的，根据一定的时间规律循环交替亮起或熄灭。每个人都应该遵守交通规则，这可以避免许多交通事故。
想学习交通灯的原理吗？我们可以用红、黄、绿3个LED外接电路来模拟马路上的交通灯。因此我们特别设计了这款交通灯模块，模块上的红、黄、绿3个LED灯模拟交通灯。
---
1.2 模块参数
工作电压 : DC 5V
电流 ：100 mA
最大功率 ：0.5 W
工作温度 ：-10°C ~ +50°C
输入信号 : 数字信号
尺寸 ：47.6 x 23.8 x 11.8 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 5pin防反接口
---
1.3 模块原理图
上一课我们学习了如何控制一个LED，由原理图可以得知，控制这个模块就好比分别控制3个独立的LED灯(我们这个灯可直接由单片机IO口驱动)，给对应颜色灯高电平就亮起对应的颜色。比如，我们给信号“R”输出高电平，也就是3.3V，则红色LED点亮。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 交通灯模块 x1 | XH2.54-5P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Traffic_Light.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Traffic_Light
* 功能 : 模拟交通灯
* 作者 : http://www.keyes-robot.com/
*/
int redPin = 5; // 红色LED连接GPIO5
int yellowPin = 13; // 黄色LED连接到GPIO13
int greenPin = 12; // 绿色LED连接GPIO12
void setup() {
//LED接口设置为输出模式
pinMode(greenPin, OUTPUT);
pinMode(yellowPin, OUTPUT);
pinMode(redPin, OUTPUT);
}
void loop() {
digitalWrite(greenPin, HIGH); //点亮绿色LED
delay(5000); //延迟5秒
digitalWrite(greenPin, LOW); //关闭绿色LED
for (int i = 1; i <= 3; i = i + 1) { //循环三次
digitalWrite(yellowPin, HIGH); //点亮黄色LED
delay(500); //延迟0.5秒
digitalWrite(yellowPin, LOW); //关闭黄色LED
delay(500); //延迟0.5秒
}
digitalWrite(redPin, HIGH); //点亮红色LED
delay(5000); //延迟5秒
digitalWrite(redPin, LOW); //关闭红色LED
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，你会看到模块上绿色LED亮5秒然后熄灭，黄色LED闪烁3秒然后熄灭，红色LED亮5秒然后熄灭。模块按此顺序循环亮灭。
---
1.8 代码说明
| 代码 | 说明 |
| -------------------------- | ---------------------------------------------------------- |
| pinMode(ledPin, OUTPUT) | 设置引脚的模式。OUTPUT为输出模式；INPUT为输入模式 |
| digitalWrite(ledPin, HIGH) | 设置引脚的输出电压为高\低电平。HIGH为高电平，LOW为低电平。 |
| delay(1000) | 将程序的执行暂停一段时间,也就是延时。单位是毫秒。 |
---
### 第四课 呼吸灯
1.1 项目介绍
在第二课我们学习了如何让LED闪烁。但是LED的玩法远不仅如此。在日常生活中你有没有遇到过灯光慢慢变亮或者慢慢变暗呢？这叫呼吸灯。所谓呼吸灯，就是控制LED逐渐变亮，然后逐渐变暗，循环交替。上一课我们学会了直接用高电平点亮LED，低电平熄灭LED。如果要让LED不那么亮但又不完全熄灭，介于中间状态，只需控制流过LED的电流就可以实现。电流减小LED变暗，电流增大LED变亮。所以只需要调节LED两端的电压减小或增大（电流也会随之减小或增大）就能控制LED的亮暗程度了。
数字端口电压输出只有LOW与HIGH两个开关，对应的就是0V与3.3V（或5V）的电压输出。可以把LOW定义为0，HIGH定义为1，1秒内让单片机输出500个0或者1的信号。如果这500个信号全部为1，那就是完整的3.3V；如果全部为0，那就是0V。如果010101010101这样输出，刚好一半，端口输出的平均电压就为1.65V了。这和放映电影是一个道理。我们所看的电影并不是完全连续的，它其实是每秒输出25张图片，人的肉眼分辨不出来，看上去就是连续的了，PWM也是同样的道理。如果想要不同的电压，就控制0与1的输出比例就可以了。当然这和真实的连续输出还是有差别的，单位时间内输出的0,1信号越多，控制的就越精确。
那么什么是PWM呢？PWM简称脉宽调制，是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术。
PWM的频率是指在1秒钟内，信号从高电平到低电平再回到高电平的次数，也就是说一秒钟PWM有多少个周期，单位Hz。
PWM的周期，T=1/f，T是周期，f是频率。如果频率为50Hz ，也就是说一个周期是20ms，那么一秒钟就有 50次PWM周期。
占空比，是一个脉冲周期内，高电平的时间与整个周期时间的比例，单位是% (0%-100%) 一个周期的长度。如下图所示。
这一课学习使用PWM来控制0与1的输出比例实现控制电压。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 12 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
前面实验二我们就学习了如何控制一个LED，由原理图可以得知，控制时，模块上GND VCC供电后，信号端S为高电平时，模块上LED亮起。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下代码文件''**Breath.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Breathing Led
* 功能 : 让led灯像呼吸一样忽明忽暗。
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_LED 5 //定义led引脚
#define CHN 0 //定义PWM通道
#define FRQ 1000 //定义PWM频率
#define PWM_BIT 8 //定义PWM精度
void setup() {
ledcSetup(CHN, FRQ, PWM_BIT); //设置PWM通道
ledcAttachPin(PIN_LED, CHN); //将led引脚连接到PWM通道
}
void loop() {
for (int i = 0; i < 255; i++) { //使灯光渐显
ledcWrite(CHN, i);
delay(10);
}
for (int i = 255; i > -1; i--) { //使灯光渐隐
ledcWrite(CHN, i);
delay(10);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，能看到模块上的紫色LED从暗逐渐变亮，再从亮逐渐变暗，就像呼吸一样。
---
1.8 代码说明
| 代码 | 说明 |
| -------------------------- | ------------------------------------------------------------ |
| ledcSetup(CHN,FRQ, WM_BIT) | ledcSetup这个函数是用来设置pwm通道的。用法是ledcSetup（通道号，频率，计数位数）。通道号，取值0 ~ 15。计数位数，取值0 ~ 20（该值决定ledcWrite函数中占空比的最大值，如该值写10，则占空比最大可写2^10-1=1023。 |
| ledcWrite(CHN, i) | ledcWrite这个函数用来指定通道输出一定占空比的波形。用法是：ledcWrite(通道, 占空比)。 |
---
### 第五课 RGB模块调节LED颜色
1.1 项目介绍
在这个套件中，有一个Keyes 共阴RGB模块，它采用F10-全彩RGB雾状共阴LED元件。控制时，我们需要将模块的R、G、B脚连接至单片机的PWM口。由于我们这个RGB模块是共阴的，公共管脚就接GND（共阳RGB公共管脚接VCC)。
RGB三色也就是三基色，红色、绿色、蓝色。人眼对RGB三色最为敏感，大多数的颜色可以通过RGB三色按照不同的比例合成产生。同样绝大多数单色光也可以分解成RGB三种色光。这是色度学的最基本原理，即三基色原理。RGB三基色按照不同的比例相加合成混色称为相加混色，除了相加混色法之外还有相减混色法。可根据需要相加相减调配颜色。
接下来，我们基于刚刚学习的三基色原理，通过PWM端口控制R、G、B各色的占空比，使R、G、B三色按照不同的比例合成产生多重颜色显示在LED上。
---
1.2 模块参数
工作电压 ：DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
输入信号 ：PWM信号
尺寸 ：32 x 23.8 x 16.9 mm
定位孔大小 ：直径为 4.8 mm
接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
通过调节R、G、B、三个灯的PWM值，控制LED元件显示红光、绿光和蓝光的比例，从而控制RGB模块上LED显示不同颜色灯光。当设置的PWM值越大，对应显示的颜色比例越重。理论上来说，通过调节这3中颜色光的混合比例，可以模拟出所有颜色的灯光。
---
1.4 实验组件
|  |  |  |  |
| --------------------- | --------------------- | ---------------------------- | ------------------ |
| ESP32 Plus主板 x1 | Keyes 共阴RGB模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**RGB.ino**"。
**注意：为了避免上传代码不成功，请不要在上传代码前连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : RGB LED
* 功能 : Use RGBLED to show random color.
* 作者 : http://www.keyes-robot.com/
*/
int ledPins[] = {32, 4, 2}; //定义红色，绿色，蓝色引脚
const byte chns[] = {0, 1, 2}; //定义PWM通道
int red, green, blue;
void setup() {
for (int i = 0; i < 3; i++) { //设置pwm通道，1KHz，8bit
ledcSetup(chns[i], 1000, 8);
ledcAttachPin(ledPins[i], chns[i]);
}
}
void loop() {
red = random(0, 256);
green = random(0, 256);
blue = random(0, 256);
setColor(red, green, blue);
delay(200);
}
void setColor(byte r, byte g, byte b) {
ledcWrite(chns[0], 255 - r); //共阴LED，低电平打开LED。
ledcWrite(chns[1], 255 - g);
ledcWrite(chns[2], 255 - b);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，能看到模块上RGB LED开始随机显示颜色。
---
1.8 代码说明
| 代码 | 说明 |
| --------------------------- | ------------------------------------------------------------ |
| int ledPins[] = {32, 4, 2} | 定义一个数组，这个数组是红灯、绿灯、蓝灯的引脚号。 |
| ledcSetup(chns[i], 1000, 8) | ledcSetup这个函数是用来设置pwm通道的。用法是ledcSetup（通道号，频率，计数位数）。通道号，取值0 ~ 15。计数位数，取值0 ~ 20（该值决定ledcWrite函数中占空比的最大值，如该值写10，则占空比最大可写2^10-1=1023。 |
| ledcWrite(chns[0], 255 - r) | ledcWrite这个函数用来指定通道输出一定占空比的波形。用法是：ledcWrite(通道, 占空比)。 |
---
### 第六课 按键传感器检测实验
1.1 项目介绍
在这个套件中，有一个Keyes单路按键模块，它主要由1个轻触开关组成，自带1个黄色按键帽。第二课我们学习了怎么让单片机的引脚输出一个高电平或者低电平，这节课程我们就来学习怎么读取引脚的电平。
按键模块的按键按下，单片机读取到低电平，松开按键读取到高电平。通过读取传感器上S端的高低电平，判断按键是否按下，并且在串口监视器上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 15.6 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
按键有四个引脚，其中1与3相连，2与4相连。按键未被按下时，13与24是断开的。信号端S读取的电平是被4.7K的上拉电阻R1所拉高的高电平。而当按键被按下时，13和24连通，原本上拉的13脚被24脚接的GND下拉至低电平，此时信号端S读取到低电平。即按下按键，传感器信号端S为低电平；松开按键时，信号端S为高电平。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 单路按键模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**button.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : button
* 功能 : 读键值
* 作者 : http://www.keyes-robot.com/
*/
int val = 0; //用于存储键值
int button = 5; //将按钮的引脚连接到GPIO5
void setup() {
Serial.begin(9600); //启动串口监视器，设置波特率为9600
pinMode(button, INPUT); //设置按钮引脚为输入模式
}
void loop() {
val = digitalRead(button); //读取按钮的值并将其赋值给变量val
Serial.print(val); //打印变量vald的值
if (val == 0) { //按下按钮时读取到低电平，并打印出相关的信息
Serial.print(" ");
Serial.println("Press the botton");
delay(100);
}
else { //打印按钮的释放信息
Serial.print(" ");
Serial.println("Loosen the botton");
delay(100);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
当按下传感器模块上的按键时，按键值value为0，串口监视器打印出“**0 Press the button**”；松开按键时，按键值value为1，串口监视器打印出“**1 Loosen the button**”字符。
---
1.8 代码说明
| 代码 | 说明 |
| ---------------------- | ------------------------------------------------------------ |
| pinMode(button, INPUT) | 由“ int button = 5; ”知道，定义按键管脚为GPIO5。“INPUT”设置为输入模式。通过pinMode()配置为INPUT必须使用上拉或下拉电阻（我们的模块已经使用上拉电阻R1）。该电阻的目的是在开关断开时将引脚拉至已知状态。通常选择一个4.7K/10 K欧姆的电阻，因为它的阻值足够低，可以可靠地防止输入悬空。同时，该阻值也要足够高，以使开关闭合时不会消耗太多电流。如果使用下拉电阻，则当开关断开时，输入引脚将为低电平；当开关闭合时，输入引脚将为高电平。如果使用上拉电阻，则当开关断开时，输入引脚将为高电平；当开关闭合时，输入引脚将为低电平。 |
| if( ){ } else{ } | 如果（ ）里的表达式为真，则执行 if { }块内的代码。如果（ ）里表达式为假 ，则执行 else { }块内的代码。 |
| digitalRead(button) | 读取按键的数字电平，高HIGH或者低LOW。如果该引脚未连接任何东西，则digitalRead( )可以返回HIGH或LOW（并且可以随机更改）。 |
| Serial.begin(9600) | 初始化串口通信，并设置波特率为9600。 |
---
### 第七课 避障传感器检测障碍物
1.1 项目介绍
在这个套件中，有一个Keyes 避障传感器，它主要由一对红外线发射与接收管元件组成。实验中，我们通过读取传感器上S端高低电平，判断是否存在障碍物。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 50 mA
最大功率 : 0.3 W
工作温度 ：-10°C ~ +50°C
输出信号 : 数字信号
感应距离 : 2 ~ 40 cm
尺寸 ：32 x 23.8 x 11 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
NE555时基电路提供给发射管TX发射出一定频率的红外信号，红外信号会随着传送距离的加大逐渐衰减，如果遇到障碍物，就会形成红外反射。当检测方向RX遇到反射回来的信号比较弱时，接收检测引脚输出高电平，说明障碍物比较远；当反射回来的信号比较强，接收检测引脚输出低电平，说明障碍物比较近，此时指示灯亮起。传感器上有两个电位器，一个用于调节发送功率，一个用于调节接收频率，通过调节两个电位器，我们可以调节它的有效距离。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 避障传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码
文件''**obstacle_avoidance_sensor.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : obstacle avoidance sensor
* 功能 : 读取避障值
* 作者 : http://www.keyes-robot.com/
*/
int val = 0;
void setup() {
Serial.begin(9600); //设置波特率为9600
pinMode(5, INPUT); //设置引脚GPIO5为输入模式
}
void loop() {
val = digitalRead(5); //读取数字电平
Serial.print(val); //打印读取的电平信号
if (val == 0) { //障碍物检测
Serial.print(" ");
Serial.println("There are obstacles");
delay(100);
}
else { //未发现障碍物
Serial.print(" ");
Serial.println("All going well");
delay(100);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，接着开始调节传感器模块上的两个电位器感应距离。避障传感器上有两个电位器，分别是接收频率调节电位器和发射功率调节电位器，如下图所示。
先调节发射功率调节电位器，先将电位器顺时针拧到尽头，然后逆时针慢慢往回调，当调节到SLED灯亮起时，微调使传感器上SLED灯介于亮与不亮之间的**不亮**状态。
接着设置接收频率调节电位器，同样将电位器顺时针拧到尽头，然后逆时针慢慢往回调，当SLED灯亮起时，微调使传感器上SLED灯介于亮与不亮之间的**不亮**状态，此时能检测障碍物的距离最长。
打开串口监视器，设置波特率为**9600**。当传感器检测到障碍物时，value 值为 **0**，SLED 灯亮，串口监视器打印出 “**0 There are obstacles**” ；没有检测到障碍物时，value 值为 **1**，SLED 灯灭，串口监视器打印出 “**1 All going well**” 。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第八课 倾斜模块的原理
1.1 项目介绍
在这个套件中，有一个Keyes 倾斜传感器，主要由一个倾斜开关组成，其内部带有一颗滚珠，用来监测倾斜情况。倾斜开关可以依据模块是否倾斜而输出不同的电平信号。当开关高于水平位置倾斜时开关导通，低于水平位置时开关断开。倾斜模块可用于倾斜检测、报警器制作或者其他检测。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.3 W
工作温度 ：-10°C ~ +50°C
输出信号 : 数字信号
尺寸 ：32 x 23.8 x 8 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
Keyes 倾斜传感器的原理非常简单，主要是利用滚珠在开关内随不同倾斜角度的变化使滚珠开关P1的引脚1和2导通或者不导通，当滚珠开关P1的引脚1和2导通时，由于1脚接GND，所以信号端S被拉低为低电平，此时红色LED和R2组成的电路形成回路，电流经过红色LED，点亮红色LED；当滚珠开关P1的引脚1和2不导通时，滚珠开关P1的引脚2被4.7K的上拉电阻R1拉高使得信号端S为高电平，电流不经过红色LED，红色LED熄灭。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 倾斜传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Tilt switch.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Tilt switch
* 功能 : 读取倾斜传感器值
* 作者 : http://www.keyes-robot.com/
*/
int val; //定义一个变量val用来存储倾斜传感器输出的电平值
void setup() {
Serial.begin(9600);
pinMode(5, INPUT); //将倾斜传感器的引脚连接到GPIO5，设置为输入模式
}
void loop() {
val = digitalRead(5); //读取模块电平信号
Serial.println(val); //打印倾斜传感器输出的电平值
delay(100); //延迟100毫秒
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
将倾斜模块往某一边倾斜，若模块上的红色LED**不亮**，串口监视器打印数字电平信号“**1**”；若模块上的红色LED点**亮**，串口监视器打印数字电平信号“**0**”。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第九课 干簧管检测附近磁场
1.1 项目介绍
在这个套件中，有一个Keyes 干簧管模块，它主要由一个MKA10110 绿色磁簧元件组成。簧管是干式舌簧管的简称，是一种有触点的无源电子开关元件，具有结构简单，体积小便于控制等优点。它的外壳是一根密封的玻璃管，管中装有两个铁质的弹性簧片电板，还灌有一种惰性气体。
实验中，我们通过读取模块上S端高低电平，判断模块附近是否存在磁场；并且在串口监视器上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.3 W
工作温度 ：-10°C ~ +50°C
输出信号 : 数字信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
一般状态下，玻璃管中的两个由特殊材料制成的簧片是分开的，此时信号端S被电阻R2上拉为高电平，LED熄灭。当有磁性物质靠近玻璃管时，在磁场磁力线的作用下，管内的两个簧片被磁化而互相吸引接触，簧片就会吸合在一起，使结点所接的电路连通，即信号端S连通GND，此时LED点亮。外磁力消失后，两个簧片由于本身的弹性而分开，线路也就断开了。该传感器就是利用元件这一特性，搭建电路将磁场信号转换为高低电平变换信号。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 干簧管模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Reed_Switch.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Reed Switch
* 功能 : 读取簧片传感器的值
* 作者 : http://www.keyes-robot.com/
*/
int val = 0;
int reedPin = 5; //定义连接到干簧管模块的信号引脚为GPIO5
void setup() {
Serial.begin(9600); //波特率设置为9600
pinMode(reedPin, INPUT); //设置干簧管模块信号引脚为输入模式
}
void loop() {
val = digitalRead(reedPin); //读取干簧管模块信号引脚数字电平
Serial.print(val); //在串口打印出来
if (val == 0) { //附近有一个磁场
Serial.print(" ");
Serial.println("A magnetic field");
delay(100);
}
else { //附近没有磁场
Serial.print(" ");
Serial.println("There is no magnetic field");
delay(100);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
拿一块带有磁性的物体靠近干簧管模块，当模块检测到磁场时，value值为0且模块上的红色LED点亮，串口监视器打印出“**0 A magnetic field**”；没有检测到磁场时，value值为1，模块上红色LED熄灭，串口监视器打印出“**1 There is no magnetic field**”。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第十课 附近有人吗
1.1 项目介绍
在这个套件中，有一个Keyes 人体红外热释传感器，它主要由一个RE200B-P传感器元件组成。它是一款基于热释电效应的人体热释运动传感器，能检测到人体或动物身上发出的红外线，配合菲涅尔透镜能使传感器探测范围更远更广。
实验中，通过读取模块上S端高低电平，判断附近是否有人在运动；并且在串口监视器上显示测试结果。
---
1.2 模块参数
工作电压 : DC 5 ~ 15V
工作电流 : 50 mA
最大功率 : 0.3 W
静态电流 : <50 uA
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
触发方式 : L 不可重复触发/H 重复触发
最大检测距离 : 7米
感应角度 : <100 度锥角
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
这个模块的原理图可能较前面的模块稍复杂，我们一部分一部分来看。先看电压转换部分，作用是将5V输入电压转换为3.3V输入电压。因为我们模块上用到的热释电红外传感器的工作电压是3.3V，不能直接用5V电压供电使用。有了这个电压转换部分，3.3V输入电压和5V输入电压都适用于此热释电红外传感器。
当红外热释传感器没有检测到红外信号时，红外热释传感器的1脚输出低电平，此时模块上的LED两端有电压差，有电流流过，LED被点亮，MOS管Q1导通（Q1是NPN MOS管，型号为2N7002。由于红外热释传感器的1脚输出低电平，所以Q1的源极Vs=0，而Q1的栅极Vg=3.3V，于是Q1的栅极G和Q1的源极S之间的电压 Vgs = 3.3V 大于Q1的阈值电压 2.5V，Q1导通。），信号端S检测到低电平。
当红外热释传感器检测到红外信号时，红外热释传感器的1脚输出高电平，此时模块上的LED熄灭，MOS管Q1不导通，则信号端S检测到被10K上拉电阻R5拉高的高电平。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | --------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 人体红外热释传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**PIR_motion.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : PIR motion
* 功能 : 读取人体红外传感器的数值
* 作者 : http://www.keyes-robot.com/
*/
int val = 0;
int pirPin = 5; //PIR运动传感器的引脚定义为GPIO5
void setup() {
Serial.begin(9600); //波特率设置为9600
pinMode(pirPin, INPUT); //将传感器设置为输入模式
}
void loop() {
val = digitalRead(pirPin); //读取传感器值
Serial.print(val); //打印传感器值
if (val == 1) { //附近有人移动，输出高电平
Serial.print(" ");
Serial.println("Some body is in this area!");
delay(100);
}
else { //如果附近没有人移动，输出低电平
Serial.print(" ");
Serial.println("No one!");
delay(100);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
当传感器检测到附近有人在运动时，value值为1，模块上LED熄灭，串口监视器显示“**1 Somebody is in this area!**”；没有检测到附近有人在运动时，value值为0，模块上LED点亮，串口监视器显示“**0 No one!**”。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第十一课 有源蜂鸣器模块播放声音
1.1 项目介绍
在这个套件中，有一个有源蜂鸣器模块，还有一个功放模块（原理相当于无源蜂鸣器）。在这个实验中，我们来学习尝试控制有源蜂鸣器发出声音。有源蜂鸣器元件内部自带震荡电路，使用时，我们只需要给蜂鸣器元件足够的电压，蜂鸣器就会自动响起。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
输入信号 : 数字信号
尺寸 ：32 x 23.8 x 12.3 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
从原理图我们可以得知，蜂鸣器的1脚通过串联一个电阻R2连接到电压正极；蜂鸣器的2脚连接到NPN三极管Q1的C极，集电极；Q1的B极，也就是基极通过串联一个电阻R1连接到S信号端；发射集接到GND。
当三极管Q1导通时，蜂鸣器的2脚连通GND，有源蜂鸣器便会工作。那么如何让三极管Q1导通呢？**NPN三极管的导通条件是基极（B）电压比发射极（E）电压高 0.3V 以上，**只需要基极（B）被上拉至高电平即可。虽然三极管Q1的基极（B）有一个下拉电阻R3导致其不导通，但是R3电阻的阻值大，使其为弱下拉电阻。三极管Q1的基极（B）还连接了一个阻值小的强上拉电阻R1，只要我们用单片机IO口给S信号端输入高电平，强上拉电阻R1会将三极管Q1的基极（B）强上拉为高电平，三极管Q1就会导通，有源蜂鸣器就会工作。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 有源蜂鸣器模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Active_buzzer.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Active buzzer
* 功能 : 有源蜂鸣器产生声音
* 作者 : http://www.keyes-robot.com/
*/
int buzzer = 5; //定义蜂鸣器接收器引脚为GPIO5
void setup() {
pinMode(buzzer, OUTPUT); //设置输出模式
}
void loop() {
digitalWrite(buzzer, HIGH); //发声
delay(1000);
digitalWrite(buzzer, LOW); //停止发声
delay(1000);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，模块上有源蜂鸣器响起1秒，停1秒，循环交替。
---
1.8 代码说明
| 代码 | 说明 |
| -------------------------- | ----------------- |
| digitalWrite(buzzer, HIGH) | GPIO5口输出高电平 |
| digitalWrite(buzzer, LOW) | GPIO5口输出低电平 |
---
### 第十二课 8002b功放 喇叭模块
1.1 项目介绍
在这个套件中，有一个Keyes 8002b功放 喇叭模块，这个模块主要由一个可调电位器、一个喇叭和一个音频放大芯片组成。上一课我们学习了有源蜂鸣器模块的使用方法，这一课我们来学习套件中的8002b功放 喇叭模块的使用方法。这个模块主要功能是：可以对输出的小音频信号进行放大，大概放大倍数为8.5倍，并且可以通过自带的小功率喇叭播放出来，也可以用来播放音乐，作为一些音乐播放设备的外接扩音设备。
---
1.2 模块参数
工作电压 : DC 5V
工作电流 : ≥100 mA
最大功率 : 2.5 W
喇叭功率 : 0.15 W
喇叭声音 : 80 db
放大芯片 : SC8002B
工作温度 ：-10°C ~ +50°C
尺寸 ：47.6 x 23.8 x 10 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
其实这个喇叭就类似于于一个无源蜂鸣器，上一课我们介绍过，有源蜂鸣器自带振荡源，只要我们给它足够的电压就能响起来，而无源蜂鸣器元件内部不带震荡电路，需要在元件正极（也就是1脚）输入不同频率的方波，负极（也就是2脚）接地，从而控制蜂鸣器响起不同频率的声音。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | --------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 8002b功放 喇叭模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Passive_buzzer.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Passive Buzzer
* 功能 : 喇叭播放音乐
* 作者 : http://www.keyes-robot.com/
*/
#define LEDC_CHANNEL_0 0
// led定时器使用13位精度
#define LEDC_TIMER_13_BIT 13
// 定义I/O端口
#define BUZZER_PIN 4
//创建一个音乐旋律列表，超级马里奥
int melody[] = {330, 330, 330, 262, 330, 392, 196, 262, 196, 165, 220, 247, 233, 220, 196, 330, 392, 440, 349, 392, 330, 262, 294, 247, 262, 196, 165, 220, 247, 233, 220, 196, 330, 392,440, 349, 392, 330, 262, 294, 247, 392, 370, 330, 311, 330, 208, 220, 262, 220, 262,
294, 392, 370, 330, 311, 330, 523, 523, 523, 392, 370, 330, 311, 330, 208, 220, 262,220, 262, 294, 311, 294, 262, 262, 262, 262, 262, 294, 330, 262, 220, 196, 262, 262,262, 262, 294, 330, 262, 262, 262, 262, 294, 330, 262, 220, 196};
//创建音调持续时间列表
int noteDurations[] = {8,4,4,8,4,2,2,3,3,3,4,4,8,4,8,8,8,4,8,4,3,8,8,3,3,3,3,4,4,8,4,8,8,8,4,8,4,3,8,8,2,8,8,8,4,4,8,8,4,8,8,3,8,8,8,4,4,4,8,2,8,8,8,4,4,8,8,4,8,8,3,3,3,1,8,4,4,8,4,8,4,8,2,8,4,4,8,4,1,8,4,4,8,4,8,4,8,2};
void setup() {
pinMode(BUZZER_PIN, OUTPUT); //设置蜂鸣器为输出模式
}
void loop() {
int noteDuration; //创建一个变量noteDuration
for (int i = 0; i < sizeof(noteDurations); ++i)
{
noteDuration = 800/noteDurations[i];
ledcSetup(LEDC_CHANNEL_0, melody[i]*2, LEDC_TIMER_13_BIT);
ledcAttachPin(BUZZER_PIN, LEDC_CHANNEL_0);
ledcWrite(LEDC_CHANNEL_0, 50);
delay(noteDuration * 1.30); //延迟
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，功放喇叭模块循环播放音乐。如果觉得喇叭声音太大或太小，可以使用十字螺丝刀调节模块上的电位器以调整音量大小。
---
1.8 代码说明
| 代码 | 说明 |
| --------------------------------------------------------- | ------------------------------------------------------------ |
| #define LEDC_TIMER_13_BIT 13 | 使用13位精度的LEDC定时器。 |
| int melody[] | 创建音乐旋律列表。 |
| int noteDurations[] | 创建音调持续时间列表。 |
| ledcSetup(LEDC_CHANNEL_0, melody[i]*2, LEDC_TIMER_13_BIT) | 设置 LEDC 通道0对应的频率和计数位数（占空比分辨率）。 |
| ledcAttachPin(BUZZER_PIN, LEDC_CHANNEL_0) | 将 LEDC 通道0绑定到指定 IO 口上以实现输出。 |
| ledcWrite(LEDC_CHANNEL_0, 50) | 指定通道0输出一定占空比波形 |
| sizeof(noteDurations) | sizeof是一个操作符（operator）。其作用是返回一个对象或类型所占的内存字节数。 |
---
### 第十三课 读取旋转电位器传感器的值
1.1 项目介绍
在这个套件中，有一个Keyes 旋转电位器传感器，它一个模拟传感器。前面我们学习过的传感器，都是数字传感器。例如我们前面学习的按键模块，当按键没有按下去时，我们读取到高电平（3.3V），当按键按下去时，我们读取到低电平（0V），而在0~3.3V中间的电压值，我们数字IO口无法读取到，当然按键模块也只能输出高低电平。而模拟传感器就可以通过我们ESP32主板上的16个ADC模拟口读取中间的电压值。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作电流 : 20 mA
工作功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 28.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
旋转电位器原理是靠电刷在电阻体上滑动，在电路中获取与输入电压形成一定关系地输出电压。Keyes 旋转电位器传感器选用了一个10K可调电阻。通过旋转电位器，我们可以改变电阻大小，信号端S检测到电压变化（0 ~ 3.3V），而这个电压变化是一个连续变化的模拟量，也就是在0~3.3V内可以取任意值，我们必须先对这个模拟量进行ADC采集，来测量连续的这些模拟量。A/D 是模拟量到数字量的转换，依靠的是模数转换器(Analog to Digital Converter)，简称ADC。我们的ESP32主板已经集成了ADC采集，可以直接使用。
我们的ESP32主板ADC位数是12位。一个 n 位的 ADC 表示这个 ADC 共有 2 的 n 次方个刻度，12位的 ADC，输出的是从0～4095一共4096个数字量，也就是 2 的 12 次方个数据刻度，每个刻度就是3.3V/4095≈0.00081V，这也叫分辨率。
ADC：ADC是一种电子集成电路，用于将模拟信号(如电压)转换为由1和0表示的数字信号。我们在ESP32上的ADC的范围是12位（ADC的位数表示将模拟量转换成数字量后所用的二进制位数），其可存储数字量范围为：0 ~ 2^12即0 ~ 4096。假设它的参考电压是3.3V，也就是说把参考电压分成4095份，最小分辨率为3.3V/4095，模拟值的范围对应于ADC值。因此，ADC拥有的比特越多，模拟的分区就越密集，最终转换的精度也就越高。
纵坐标数字0 : 0V ~ 3.3/4095V 范围内的模拟量（横坐标）;
纵坐标数字1 : 3.3/ 4095V ~ 2*3.3 /4095V 范围内的模拟量（横坐标）;
......
模拟将被相应地划分。换算公式如下：
DAC：这一过程的可逆需要DAC，数字到模拟转换器。数字I/O端口可以输出高电平和低电平(0或1)，但不能输出中间电压值，这就是DAC有用的地方。ESP32有两个8位精度的DAC输出引脚GPIO25和GPIO26，可以将VCC(这里是3.3V)分成2*8=256个部分。例如，当数字量为1时，输出电压值为3.3/256 * 1V，当数字量为128时，输出电压值为3.3/256 *128=1.65V, DAC的精度越高，输出电压值的精度就越高。
换算公式如下：
ADC on ESP32：
ESP32有16个引脚，可以用来测量模拟信号。GPIO引脚序列号和模拟引脚定义如下表所示：
| **ADC number in ESP32** | **ESP32 GPIO number** |
| ----------------------- | --------------------- |
| ADC0 | GPIO 36 |
| ADC3 | GPIO 39 |
| ADC4 | GPIO 32 |
| ADC5 | GPIO33 |
| ADC6 | GPIO34 |
| ADC7 | GPIO 35 |
| ADC10 | GPIO 4 |
| ADC11 | GPIO0 |
| ADC12 | GPIO2 |
| ADC13 | GPIO15 |
| ADC14 | GPIO13 |
| ADC15 | GPIO 12 |
| ADC16 | GPIO 14 |
| ADC17 | GPIO27 |
| ADC18 | GPIO25 |
| ADC19 | GPIO26 |
DAC on ESP32：
ESP32有两个8位数字模拟转换器，分别连接到GPIO25和GPIO26引脚，它是不可变的。如下表所示：
| **Simulate pin number** | **GPIO number** |
| ----------------------- | --------------- |
| DAC1 | GPIO25 |
| DAC2 | GPIO26 |
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 旋转电位器传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Rotary_potentiometer.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Rotary_potentiometer
* 功能 : 读取旋转电位器传感器的值，将其转化为ADC、DAC和电压值
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_ANALOG_IN 34 //电位器的引脚
void setup() {
Serial.begin(9600);
}
//在loop()中，使用analogRead()函数获取ADC值，
//然后使用map()函数将该值转换为8位精度DAC值。
//输入输出电压按下面公式计算，
//最后，将信息打印出来。
void loop() {
int adcVal = analogRead(PIN_ANALOG_IN);
int dacVal = map(adcVal, 0, 4095, 0, 255);
double voltage = adcVal / 4095.0 * 3.3;
Serial.printf("ADC Val: %d, \t DAC Val: %d, \t Voltage: %.2fV\n", adcVal, dacVal, voltage);
delay(200);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
转动电位器手柄时，串口监视器打印出此时电位器的ADC值、DAC值和电压的值。
---
1.8 代码说明
| 代码 | 说明 |
| ----------------------------------------- | ------------------------------------------------------------ |
| analogRead(PIN_ANALOG_IN) | 从指定的模拟引脚读取值。ESP32主板包含一个多通道、12位模数转换器。 这意味着它会将 从0V和工作电压（5V 或 3.3V，本实验中是3.3V）之间的输入电压映射为0和4095之间的整数值。这会产生以下分辨率：3.3V/4096单位即每单位 0.0008V。 |
| int dacVal = map(adcVal, 0, 4095, 0, 255) | 将adcVal读到的值从 0 ~ 4095 映射到 0 ~ 255，也就是转换为占空比对应的值。 |
| double voltage = adcVal / 4095.0 * 3.3 | 以double（双精度）浮点型输出电压值。 |
---
### 第十四课 声音传感器检测声量
1.1 项目介绍
在这个套件中，有一个Keyes 声音传感器。实验中，我们利用这个传感器测试当前环境中的声音对应的ADC值、DAC值和输出的电压值。声音越大，ADC值、DAC值和电压值越大；并在串口监视器上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作电流 : 100 mA
最大功率 : 0.5 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 10.3 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
Keyes 声音传感器主要由一个高感度麦克风元件和LM386音频功率放大器芯片组成。高感度麦克风元件用于检测外界的声音。利用LM386音频功率放大器芯片设计对高感度麦克风检测到的声音进行放大的电路，最大倍数为200倍。使用时我们可以通过旋转传感器上电位器，调节声音的放大倍数。顺时针调节电位器到尽头，放大倍数最大。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 声音传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**MicroPhone.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : MicroPhone
* 功能 : 将接收到的声音转化为对应的ADC值、DAC值和电压值
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_ANALOG_IN 34 //声音传感器的引脚
void setup() {
Serial.begin(9600);
}
//在loop()中，使用analogRead()函数获取ADC值，
//然后使用map()函数将该值转换为8位精度DAC值。
//输入输出电压按下面公式计算，
//打印信息
void loop() {
int adcVal = analogRead(PIN_ANALOG_IN);
int dacVal = map(adcVal, 0, 4095, 0, 255);
double voltage = adcVal / 4095.0 * 3.3;
Serial.printf("ADC Val: %d, \t DAC Val: %d, \t Voltage: %.2fV\n", adcVal, dacVal, voltage);
delay(200);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
串口监视器打印出声音传感器接收到的声音对应的ADC值、DAC值和电压值。对准MIC头大声说话，可以看到接收到的声音对应的ADC值、DAC值和电压值变大。
---
1.8 代码说明
此课程代码与第十三课代码类似，这里就不多做介绍了。
---
### 第十五课 光敏电阻传感器
1.1 项目介绍
在这个套件中，有一个Keyes 光敏电阻传感器，这是一个常用的光敏电阻传感器，它主要由一个光敏电阻元件组成。光敏电阻元件的阻值随着光照强度的变化而变化，此传感器就是利用光敏电阻元件这一特性，设计电路将阻值变化转换为电压变化。光敏电阻传感器可以模拟人对环境光线的强度的判断，方便做出与人友好互动的应用。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 20 mA
最大功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
当没有光照射时，电阻大小为0.2 MΩ，光敏电阻的信号端（2脚）检测的电压接近0。随着光照强度增大，光线传感器的电阻值越来越小，所以信号端能检测到的电压越来越大。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 光敏电阻传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Photoresistance.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Photoresistance
* 功能 : 将光敏电阻的阻值转换成ADC,DAC和电压值
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_ANALOG_IN 34 //光敏电阻的引脚
void setup() {
Serial.begin(9600);
}
//在loop()中，使用analogRead()函数获取ADC值，
//然后使用map()函数将该值转换为8位精度DAC值。
//输入输出电压按下面公式计算，
//将信息打印出来
void loop() {
int adcVal = analogRead(PIN_ANALOG_IN);
int dacVal = map(adcVal, 0, 4095, 0, 255);
double voltage = adcVal / 4095.0 * 3.3;
Serial.printf("ADC Val: %d, \t DAC Val: %d, \t Voltage: %.2fV\n", adcVal, dacVal, voltage);
delay(200);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
串口监视器打印出光敏传感器的ADC值、DAC值和电压值。光照越强，可以看到ADC值，DAC值和电压值越大。
---
1.8 代码说明
此课程代码与第十三课代码类似，这里就不多做介绍了。
---
### 第十六课 NTC-MF52AT模拟温度传感器
1.1 项目介绍
在这个套件中，有一个Keyes NTC-MF52AT模拟温度传感器，它的原理与光敏电阻传感器类似，只是感应的器件不同。将传感器信号端接到ESP32主板模拟口，可以读出对应的ADC值，电压值和温度值。我们可以利用ADC值，输出电压值，通过特定公式，计算出当前环境的温度。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 20 mA
最大功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
Keyes NTC-MF52AT模拟温度传感器主要由NTC-MF52AT热敏电阻元件组成。NTC-MF52AT热敏电阻元件能够感知周边环境温度的变化，随着温度的升高，热敏电阻的阻值降低，4.7K电阻两端的电压上升，从而引起信号端S的电压变化。
**NTC 热敏电阻温度计算公式：Rt = R * EXP( B * (1/T1-1/T2) ) 。**
其中，T1和T2指的是K度，即开尔文温度。K度=273.15(绝对温度)+摄氏度。
Rt 是热敏电阻在周围温度为T1（当前温度）时的电阻值。
R是热敏电阻在周围温度为T2常温（常温取25℃）时的标称阻值。参考规格书可知我们用的NTC-MF52AT模拟温度传感器在 25℃ 下热敏电阻的零功率电阻值为10KΩ ± 5%（即R=10K），T2=(273.15+25) 。
B值是热敏电阻的重要参数，为材料常数，在25℃下测得。参考规格书可知B值为 3950±1%。
EXP() 是e^()，e的n次方。
通过转换可以得到温度T1与电阻Rt的关系：T1=1 / (ln(Rt/R) /B+1/T2) ，这里可以将ln换算成log，即T1=1/ ( log(Rt/R)/B + 1/T2 ) 。
那么我们唯一需要知道的就是Rt的值。回到上面的原理图，设热敏电阻两端电压为VRt，固定的 R1电阻两端的电压为VR，由电阻分压知识VR/VRt = R1/Rt可以知道：Rt = R1 *(3.3-VR)/VR 。而我们实际得到的VR是转换后的ADC值，需要转换成电压值，即VR = adcValue / 4095.0 * 3.3。
**注意**：计算出来的温度是开尔文温度，因此需要减去K值，对应的摄氏温度 t = T1 - 273.15，同时加上0.5的误差矫正。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | --------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | NTC-MF52AT模拟温度传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Temperature_sensor.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Temperature sensor
* 功能 : 用热敏电阻制作温度计
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_ANALOG_IN 34
void setup() {
Serial.begin(9600);
}
void loop() {
int adcValue = analogRead(PIN_ANALOG_IN); //读ADC引脚
float Rt=0; //NTC 热敏电阻
float R=10000; //具有固定电阻值的10K电阻
float T2=273.15+25; //转换成开尔文温度
float B=3950; //B值是热敏电阻的一个重要参数
float K=273.15; //开氏度 (K°)
float VR=0;
VR = (float)(adcValue / 4095.0 * 3.3); //转换成电压值
Rt = (3.3 - VR) / VR * 4700; //计算NTC热敏电阻
float temp = 1/(1/T2+log(Rt/R)/B)-K+0.5;//计算温度
Serial.printf("ADC value : %d,\tVoltage : %.2fV, \tTemperature : %.2fC\n", adcValue, VR, temp);
delay(1000);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
串口监视器打印出热敏传感器当前所处环境下的ADC值、电压值和温度值。
---
1.8 代码说明
| 代码 | 说明 |
| --------------------------------------- | ------------------------------------------------------------ |
| VR = (float)(adcValue / 4095.0 * 3.3) | 将R1电阻两端转换后的ADC值转换成电压值，数据类型为单精度浮点型。 |
| Rt = (3.3 - VR) / VR * 4700 | 计算热敏电阻在当前温度下的电阻值。 |
| float temp = 1/(1/T2+log(Rt/R)/B)-K+0.5 | 计算当前环境的温度，数据类型为单精度浮点型。 |
---
### 第十七课 薄膜压力传感器
1.1 项目介绍
在这个套件中，有一个Keyes 薄膜压力传感器，薄膜压力传感器是基于新型纳米压敏材料辅以舒适杨式模量的超薄薄膜衬底一次性贴片而成，兼具防水和压敏双重功能。
通过采集模块上S端模拟信号，判断压力大小。ADC值、DAC值和电压值越小，压力越大；并在串口监视器上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 20 mA
最大功率 : 0.1W
量程 : 0-5KG
响应点 : 150g
重复性 : ＜±9.7%（60%负载）
一致性 : ±10%
耐久性 : ＞100万次
初始电阻 : 大于10MΩ(无负载)
响应时间 : ＜1ms
恢复时间 : ＜15ms
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
当传感器感知到外界压力时，传感器的电阻值发生变化。Keyes 薄膜压力传感器使用LM321运算放大器芯片将传感器感知到的压力变化的压力信号转换成相应变化强度的电信号输出。这样就可以通过检测电压信号变化得知压力变化情况。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 薄膜压力传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Film_pressure_sensor.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Film pressure sensor
* 功能 : 将薄膜压力传感器感受到的压力值转换为ADC,DAC和电压
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_ANALOG_IN 34 //薄膜压力传感器的引脚
void setup() {
Serial.begin(9600);
}
//在loop()中，使用analogRead()函数获取ADC值，
//然后使用map()函数将该值转换为8位精度DAC值。
//输入输出电压按上式计算，
//最后将信息打印出来。
void loop() {
int adcVal = analogRead(PIN_ANALOG_IN);
int dacVal = map(adcVal, 0, 4095, 0, 255);
double voltage = adcVal / 4095.0 * 3.3;
Serial.printf("ADC Val: %d, \t DAC Val: %d, \t Voltage: %.2fV\n", adcVal, dacVal, voltage);
delay(200);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。为了使实验数据最精准，请将薄膜压力传感器尽量平放。
串口监视器打印出薄膜压力传感器的ADC值、DAC值和电压值。用手按压薄膜时，随着力量的增大，可以看到ADC值，DAC值和电压值逐渐变小。
---
1.8 代码说明
此课程代码与第十三课代码类似，这里就不多做介绍了。
---
### 第十八课 摇杆模块
1.1 项目介绍
你看过游戏手柄吗？游戏手柄上有按键，还有摇杆。摇杆是什么工作原理呢？在我们这个套件中，就有一个Keyes 摇杆模块，它的主要元件是PS2手柄摇杆。控制时，我们需要将模块的X端口和Y端口连接至单片机的模拟口。B端口连接至单片机数字口，V端口接至单片机电源输出端（3.3-5V），GND接单片机GND。通过读取两个模拟值和一个数字口的高低电平情况，可以判断模块上摇杆的工作状态。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.25 W
输出信号 : 信号端X、Y 模拟电压输出
信号端B : 数字电平输出
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：47.6 x 23.8 x 34.5 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 5pin防反接口
---
1.3 模块原理图
其实它的原理非常简单，内部相当于两个可调电位器（左右和上下）和一个按键。按键没有按下时被R1下拉为低电平，按下时接通VCC即为高电平，与我们前面学习过的按键模块的电平值是相反的。摇动摇杆时内部的电位器就会根据摇杆的摇动调节，从而输出不同的电压，可以读取到模拟值。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 摇杆模块 x1 | XH2.54-5P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Joystick.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Joystick
* 功能 : 从摇杆读取数据
* 作者 : http://www.keyes-robot.com/
*/
int xyzPins[] = {34, 35, 13}; //x,y,z 引脚
void setup() {
Serial.begin(9600);
pinMode(xyzPins[0], INPUT); //x轴
pinMode(xyzPins[1], INPUT); //y轴
pinMode(xyzPins[2], INPUT_PULLUP); //z轴是一个按钮
}
// 在loop()中，使用analogRead()读取x轴和y轴的值
//并使用digitalRead()读取z轴的值，然后显示它们。
void loop() {
int xVal = analogRead(xyzPins[0]);
int yVal = analogRead(xyzPins[1]);
int zVal = digitalRead(xyzPins[2]);
Serial.println("X,Y,Z: " + String(xVal) + ", " + String(yVal) + ", " + String(zVal));
delay(500);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
串口监视器窗口将打印出当前摇杆X轴和Y轴对应的模拟值以及Z轴对应的数字值，移动摇杆或按下它将改变串口监视器中的模拟值和数字值。当按下摇杆时，Z值为1；未按下摇杆时，Z值为0。X值从左到右由0增长到4095。Y值从下到上由0增长到4095。
在X轴上移动摇杆，使数据从小到大。
在Y轴上移动摇杆，使数据从小到大。
按下摇杆。
---
1.8 代码说明
| 代码 | 说明 |
| --------------------------------- | -------------------------- |
| pinMode(xyzPins[2], INPUT_PULLUP) | 将引脚设置为输入上拉模式。 |
---
### 第十九课 SK6812 RGB
1.1 项目介绍
第六课学习了插件RGB模块，利用PWM信号对模块的三个引脚进行调色。我们这个套件中，还有一个Keyes 6812 RGB模块。SK6812 RGB 模块驱动原理与插件RGB模块的驱动原理不相同，只需要一个引脚控制。这是一个集控制电路与发光电路于一体的智能外控LED光源。每个LED原件其外型与一个5050LED灯珠相同，每个元件即为一个像素点，我们这个模块上有四个灯珠即四个像素点。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
最大功率 : 1W
光源 : SMD 5050 RGB
IC型号 : 4颗/WS2811
灰度等级 : 256级
发光角度 : 180°
发光颜色 : 可以通过控制器调为白，红，黄，蓝，绿,等
工作温度 ：-10°C ~ +50°C
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
从原理图中我们可以看出，这四个像素点灯珠串联。其实不论多少个灯珠串联，我们都可以用一个引脚控制其中任意一个灯让它显示任意一种颜色。像素点内部包含了智能数字接口数据锁存信号整形放大驱动电路，还包含有高精度的内部振荡器和12V高压可编程定电流控制部分，有效保证了像素点光的颜色高度一致。
数据协议采用单线归零码的通讯方式，像素点在上电复位以后，S端接受从控制器传输过来的数据，首先送过来的24bit数据被第一个像素点提取后，送到像素点内部的数据锁存器。这个6812RGB通讯协议与驱动已经在底层封装好了，我们直接调用函数的接口就可以使用。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 6812 RGB模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**SK6812.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : sk6812 RGB LED
* 功能 : 打开sk6812 RGB LED
* 作者 : http://www.keyes-robot.com/
*/
#include
#define PIN 4
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin();
strip.show(); // 将所有像素点（灯）初始化为“off”，即关闭
}
void loop() {
// 显示颜色
colorWipe(strip.Color(255, 0, 0), 50); // 红色
colorWipe(strip.Color(0, 255, 0), 50); // 绿色
colorWipe(strip.Color(0, 0, 255), 50); // 蓝色
// 剧院像素追逐
theaterChase(strip.Color(127, 127, 127), 50); // 白色
theaterChase(strip.Color(127, 0, 0), 50); // 红色
theaterChase(strip.Color( 0, 0, 127), 50); // 蓝色
rainbow(20);
rainbowCycle(20);
theaterChaseRainbow(50);
}
// 用一种颜色一个接一个地填充这些点
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i g -> b 再回到r的过渡
uint32_t Wheel(byte WheelPos) {
if(WheelPos < 85) {
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
} else if(WheelPos < 170) {
WheelPos -= 85;
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
} else {
WheelPos -= 170;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，我们可以看到模块上的4个RGB LED一个接一个地填充红色、绿色、蓝色；接着4个RGB LED以跑马灯的效果显示白色、红色、蓝色；接着4个RGB LED显示彩虹灯效果；最后再以跑马灯的效果显示彩虹灯。
---
1.8 代码说明
| 代码 | 说明 |
| -------------------------------------------- | ------------------------------------------------------------ |
| colorWipe(strip.Color(255, 0, 0), 50) | 用一种颜色一个接一个地填充RGB LED。第一个参数strip是指灯带；第二个参数Color(255, 0, 0)是颜色,代表红色；第三个参数50是等待时间。 |
| theaterChase(strip.Color(127, 127, 127), 50) | 以跑马灯的效果显示颜色。 |
| void rainbowCycle(uint8_t wait){} | 不同于colorWipe的一个接一个显示，这里均匀显示彩虹灯效果。 |
| void theaterChaseRainbow(uint8_t wait) {} | 以跑马灯的效果显示颜色彩虹灯。 |
---
### 第二十课 旋转编码器模块计数
1.1 项目介绍
在这个套件中，有一个Keyes 旋转编码器模块，也叫开关编码器、旋转编码器。此款编码器有20脉冲20定位点、15脉冲30定位点两种。编码器主要用于汽车电子、多媒体音响、仪器仪表、家用电器、智能家居、计算机周边、医疗器械等领域。主要用于频率调节、亮度调节、温度调节、音量调节的参数控制等。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 20 mA
最大功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 30.6 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 5pin防反接口
---
1.3 模块原理图
增量式编码器是将位移转换成周期性的电信号，再把这个电信号转变成计数脉冲，用脉冲的个数表明位移的巨细。Keyes 旋转编码器模块采用的是20脉冲旋转编码器元件，它可以通过旋转计数正方向和反方向转动过程中输出脉冲的次数，这种转动计数是没有限制的，复位到初始状态，即从0开始计数。
旋转编码器提供两种交互方式：
- **按钮** 单击旋钮以按下按钮。按下时，按钮将 SW 引脚与 GND 引脚连接，也就是SW引脚的电平为低电平。
- **旋转** 每次旋转旋钮时，会在 DT 和 CLK 引脚上产生一个 LOW 信号。
- 顺时针旋转会导致 CLK 引脚首先变低，然后 DT 引脚也变低。
- 逆时针旋转会导致 DT 引脚先变低，然后 CLK 引脚变低。
两个引脚将在几毫秒内返回高电平。如下图所示：
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 旋转编码器模块 x1 | XH2.54-5P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Encoder.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Encoder
* 功能 : 旋转编码器模块计数
* 作者 : http://www.keyes-robot.com/
*/
int Encoder_DT = 27;
int Encoder_CLK = 14;
int Encoder_Switch = 16;
int Encoder_Count;
void setup() {
Serial.begin(9600);
pinMode (Encoder_DT, INPUT);
pinMode (Encoder_CLK, INPUT);
pinMode (Encoder_Switch, INPUT);
}
int lastClk = HIGH;
void loop() {
int newClk = digitalRead(Encoder_CLK);
if (newClk != lastClk) {
// 在CLK引脚上有一个变化
lastClk = newClk;
int dtValue = digitalRead(Encoder_DT);
if (newClk == LOW && dtValue == HIGH) {
Encoder_Count ++;
Serial.println(Encoder_Count);
}
if (newClk == LOW && dtValue == LOW) {
Encoder_Count--;
Serial.println(Encoder_Count);
}
}
if (digitalRead(Encoder_Switch) == 0)
{
delay(5);
if (digitalRead(Encoder_Switch) == 0) {
Serial.println("Switch pressed");
while (digitalRead(Encoder_Switch) == 0);
}
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
顺时针旋转编码器，串口监视器打印出来的数据**增大**；逆时针旋转编码器，串口监视器打印出来的数据**减小**；按下编码器中间按键，串口监视器打印“**Switch pressed**”。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------------- | ------------------------------------------------------------ |
| if (newClk == LOW && dtValue == HIGH) | 如果CLK引脚为低的同时DT引脚为高，也就是CLK引脚先变低，然后DT引脚再变低。顺时针旋转旋钮。 |
| if (newClk == LOW && dtValue == LOW) | 如果CLK引脚为低的同时DT引脚也为低，也就是DT引脚先变低，然后CLK引脚再变低。逆时针旋转旋钮。 |
| digitalRead(Encoder_Switch) == 0 | 按下旋钮。 |
---
### 第二十一课 舵机的控制原理
1.1 项目介绍
舵机是一种位置伺服的驱动器，主要是由外壳、电路板、无核心马达、齿轮与位置检测器所构成。舵机有很多规格，但所有的舵机都有外接三根线。由于舵机品牌不同，颜色也会有所差异，我们实验用到的这款舵机分别用棕、红、橙三种颜色进行区分，棕色为接地线，红色为电源正极，橙色为信号线。
舵机分为360度舵机、180度舵机和90度舵机，我们实验用到的这款舵机为90度舵机，但是它转动的角度范围最大接近180度，所以我们也可把它当做180度舵机使用，控制原理都是一样的。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
尺寸 ：32.25 x 12.25 x 30.42 mm
接口 ：间距为2.54 mm 3pin接口
---
1.3 模块原理图
舵机的控制信号是周期为20ms （50Hz）的PWM（脉冲宽度调制）信号。
舵机的转动的角度是通过调节PWM信号的占空比来实现的，一般在 0.5ms ~ 2.5ms 的范围内去控制，总间隔为 2ms，相对应舵盘的位置为0度 ~ 180度，呈线性变化。当脉冲宽度为 1.5ms 时，舵机旋转至中间角度，大于 1.5ms 时舵机旋转角度增大，小于 1.5ms 时舵机旋转角度减小。
也就是说，舵机的控制需要单片机产生一个周期为20ms的脉冲信号，以0.5ms到2.5ms的高电平来控制舵机转动的角度。具体脉冲参数下图所示：
注意，由于舵机品牌不同，对于同一信号，不同品牌的舵机旋转的角度也会有所不同。
---
1.4 实验组件
|  |  |  |
| ------------------------ | ------------------- | --------------------- |
| ESP32 Plus主板 x1 | 9G 180度数字舵机 x1 | USB线 x1 |
---
1.5 实验
1.5.1 实验①：
（1）实验接线图
（2）实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**servo_1.ino**"。
```c++
/*
* 名称 : Servo_1
* 功能 : 舵机旋转角度0 -> 90 -> 180，重复
* 作者 : http://www.keyes-robot.com/
*/
#include
Servo myservo; //创建伺服对象来控制伺服电机
int servoPin = 4; // 伺服电机引脚
void setup() {
myservo.setPeriodHertz(50); //设置伺服电机频率为50Hz
myservo.attach(servoPin, 500, 2500); //将servoPin上的值映射到伺服对象上
}
void loop() {
myservo.write(0); //旋转到0度
delay(1000); //延迟1s
myservo.write(90); //旋转到90度
delay(1000); //延迟1s
myservo.write(180); //旋转到180度
delay(1000); //延迟1s
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
（3）实验结果
若代码上传不成功，提示“**ESP32Servo.h: No such file or directory**”，请添加库文件。先点击“**项目**”，选择“**加载库**”，最后选择“**添加.ZIP库**”。
根据库文件的路径打开库文件夹，选中库文件夹中 .zip格式的”**ESP32Servo.zip**“库压缩包，然后单击“**打开**”，库文件成功加入。
代码上传成功后，拔下USB线断电，按照接线图正确接好舵机后再用USB线连接到计算机上电。舵机由0度转到90度，停顿1秒；再转到180度，停顿1秒；然后回到0度，停顿1秒，循环转动。
---
1.5.2 实验②：
（1）实验接线图
（2）实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**servo_2.ino**"。
```c++
/*
* 名称 : Servo_2
* 功能 : 控制伺服电机进行扫动
* 作者 : http//www.keyestudio.com
*/
#include
Servo myservo; //创建伺服对象来控制伺服电机
int posVal = 0; // 定义一个变量，存储伺服电机位置
int servoPin = 4; // 伺服电机引脚
void setup() {
myservo.setPeriodHertz(50); //设置伺服电机频率为50Hz
myservo.attach(servoPin, 500, 2500); //将servoPin上的值映射到伺服对象上
}
void loop() {
for (posVal = 0; posVal <= 180; posVal += 1) { // 将servoPin上的伺服附加到伺服对象上
// 以1度为步
myservo.write(posVal); // 告诉伺服电机到变量“pos”的位置
delay(15); // 等待15ms让伺服电机到达位置
}
for (posVal = 180; posVal >= 0; posVal -= 1) { // 从180°到0°
myservo.write(posVal); // 告诉伺服电机到变量“pos”的位置
delay(15); // 等待15ms让伺服电机到达位置
}
}
```
（3）实验结果
代码上传成功后，拔下USB线断电。按照接线图正确接好舵机后再用USB线连接到计算机上电。舵机在0度 ~ 180度之间来回转动，每15ms转动一度。
---
1.6 代码说明
| 代码 | 说明 |
| ----------------------------------- | ------------------------------------------------------------ |
| #include | Arduino专门为了esp32推出的servo库，用来操作伺服舵机。 |
| Servo myservo | 创建一个伺服对象来控制伺服。 |
| myservo.setPeriodHertz(50) | 设置舵机频率为50Hz。 |
| myservo.attach(servoPin, 500, 2500) | 设置控制脉冲范围为500~2500us。 |
| myservo.write(posVal) | 向舵机写入一个数值，来直接控制舵机的轴，角度控制。舵机转动到posVal角度值。 |
---
### 第二十二课 超声波传感器的原理
1.1 项目介绍
蝙蝠和某些海洋动物都能够利用高频率的声音进行回声定位或信息交流。它们能通过口腔或鼻腔把从喉部产生的超声波发射出去，利用折回的声波来定向，并判定附近物体的位置、大小以及是否在移动。超声波是一种频率高于20000赫兹的声波，它的方向性好，穿透能力强，易于获得较集中的声能，在水中传播距离远，可用于测距、测速、清洗、焊接、碎石、杀菌消毒等。在医学、军事、工业、农业上有很多的应用。超声波因其频率下限大于人的听觉上限而得名。科学家们将每秒钟振动的次数称为声音的频率，它的单位是赫兹(Hz)。
在这个套件中，有一个HC-SR04超声波传感器，它可以发送出一种频率很高的人类无法听到的超声波信号，这些超声波的信号碰到障碍物，就会立刻反射回来。在接收到返回的信息之后，根据发射信号和接收信号的时间差，计算出传感器和障碍物的详细距离，和蝙蝠飞行的原理一样。
---
1.2 模块参数
超声波传感器工作电压 : DC 5V
超声波传感器工作电流 : 15 mA
超声波传感器工作频率 : 40 Hz
超声波传感器射程范围 : 2 cm ~ 4 m
超声波传感器测量角度 : <= 15度
超声波传感器输入触发信号 : 10 uS 的TTL脉冲
超声波传感器输出回响信号 : 输出TTL电平信号与射程成正比
工作温度 ：-10°C ~ +50°C
超声波传感器尺寸 ：45.5 x 26.7 x 17.6 mm
超声波转接板模块尺寸 ：32 x 23.8 x 11.85 mm
超声波转接板模块定位孔大小：直径为 4.8 mm
超声波转接板模块接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
最常用的超声测距的方法是回声探测法。当有脉冲电压触发时（单片机给Trig引脚发送高电平），超声波发射器探头里的晶片就会振动，继而产生超声波。在超声波发射时刻的同时计数器开始计时，超声波在空气中传播，途中碰到障碍物面阻挡就立即反射回来（Echo引脚发送高电平信号给单片机），超声波接收器收到反射回的超声波就立即停止计时。
超声波是一种声波，其声速V与温度有关。一般情况下超声波在空气中的传播速度为340m/s，根据计时器记录的时间t，就可以计算出超声波探头发射点距障碍物面的距离s，即：s=340t/2 。
HC-SR04超声波测距模块可提供范围为2厘米至4米的非接触式距离感测功能，测距精度可达高到3mm。超声波传感器包括超声波发射器、超声波接收器与控制电路。其基本工作原理：
(1)采用IO口Trig触发测距，给至少10us的高电平信号;
(2)模块自动发送8个40khz的方波，自动检测是否有信号返回；
(3)有信号返回，通过IO口Echo输出一个高电平，高电平持续的时间就是超声波从发射到返回的时间。
---
1.4 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 超声波转接模块 x1 | HC-SR04 超声波传感器 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Ultrasonic.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Ultrasonic
* 功能 : 使用超声波模块测量距离
* 作者 : http://www.keyes-robot.com/
*/
const int TrigPin = 13; // 定义TrigPin
const int EchoPin = 12; // 定义EchoPin
int duration = 0; // 将持续时间的初始值定义为0
int distance = 0; // 将距离的初始值定义为0
void setup()
{
pinMode(TrigPin , OUTPUT); // 设置trigPin为输出模式
pinMode(EchoPin , INPUT); // 设置echoPin为输入模式
Serial.begin(9600); // 设置波特率为9600
}
void loop()
{
// 使trigPin输出高电平持续10μs触发HC_SR04
digitalWrite(TrigPin , HIGH);
delayMicroseconds(10);
digitalWrite(TrigPin , LOW);
// 等待HC-SR04回到高电平并测量这个等待时间
duration = pulseIn(EchoPin , HIGH);
// 根据时间计算距离
distance = (duration/2) / 28.5 ;
Serial.print("Distance: ");
Serial.print(distance); //串口打印距离值
Serial.println("cm");
delay(300); //ping之间等待100毫秒(大约20个ping /秒)。
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
放置障碍物在超声波传感器探头前感应，串口监视器窗口打印出超声波传感器与障碍物之间的距离值。
---
1.8 代码说明
| 代码 | 说明 |
| ---------------------------------- | ------------------------------------------------------------ |
| duration = pulseIn(EchoPin , HIGH) | pulseIn是内置函数，专门用来读取脉冲时间间隔。这里读取的高电平的时间就是超声波从发射到返回的时间。 |
| distance = (duration/2) / 28.5 | 超声波数据转换算法。 |
---
### 第二十三课 红外遥控与接收
1.1 项目介绍
红外线遥控是目前使用最广泛的一种通信和遥控手段。因红外线遥控装置具有体积小、功耗低、功能强、成本低等特点，录音机、音响设备、空凋机以及玩具等其它小型电器装置上纷纷采用红外线遥控。红外遥控的发射电路是采用红外发光二极管发出经过调制的红外光波；红外接收电路由红外接收二极管、三极管或硅光电池组成，它们将红外发射器发射的红外光转换为相应的电信号，再送到后置放大器。
Keyes 红外接收模块选择的是VS1838B红外接收传感器元件，该元件是集接收、放大、解调一体的器件，内部IC就已经完成了解调，输出的就是数字信号。它可接收标准38KHz调制的遥控器信号。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.25 W
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 10.8 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
红外遥控系统的主要部分为调制、发射和接收。红外遥控是以调制的方式发射数据，就是把数据和一定频率的载波进行“与”操作，这样既可以提高发射效率又可以降低电源功耗。调制载波频率一般在30khz到60khz之间，大多数使用的是38kHz，占空比1/3的方波。红外接收的信号端加上了4.7K的上拉电阻R3，工作时，首先等待检测低电平，接收到信号后，信号端立即由高电平转为低电平。
---
1.4 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | -------------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 红外接收模块 x1 | Keyes 遥控器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**IR_Receiver.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : IR Receiver
* 功能 : 解码红外线遥控器，通过串口打印出来
* 作者 : http://www.keyes-robot.com/
*/
#include
#include
#include
#include
const uint16_t recvPin = 4; // 红外接收引脚
IRrecv irrecv(recvPin); // 创建一个用于接收类的类对象
decode_results results; // 创建一个解码结果类对象
void setup() {
Serial.begin(9600); // 初始化串口，波特率设置为9600
irrecv.enableIRIn(); // 启动接收器
Serial.print("IRrecvDemo is now running and waiting for IR message on Pin ");
Serial.println(recvPin); // 打印红外线接收针
}
void loop() {
if (irrecv.decode(&results)) { // 等待解码
serialPrintUint64(results.value, HEX);// 输出解码结果
Serial.println("");
irrecv.resume(); // 释放IRremote，接收下一个值
}
delay(1000);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
若代码上传不成功，提示“**IRremoteESP8266.h: No such file or directory**”，请添加库文件。先点击“**项目**”，选择“**加载库**”，最后选择“**添加.ZIP库**”。
根据库文件的路径打开库文件夹，选中库文件夹中 .zip格式的”**IRremoteESP8266.zip**“库压缩包，然后单击“**打开**”，库文件成功加入。
**注意：IRremoteESP8266 库更新至高版本可能会导致编译出错不成功，建议使用2.7.13版本。**
Keyes 遥控器上每一个按键都对应着一个按键值，如下图所示。
再次上传代码，代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
找到红外遥控器，拔出绝缘片。对准红外接收模块的红外接收传感器的接收头，按下遥控器任意按键，接收到信号后，串口监视器窗口打印出当前接收到的按键值，同时，红外接收传感器上的LED会闪烁。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------------- | ---------------------------------- |
| irrecv.enableIRIn(); | 初始化红外遥控。 |
| irrecv.decode(&results) | 等待解码。 |
| serialPrintUint64(results.value, HEX) | 打印出解码结果。 |
| irrecv.resume(); | 恢复，等待接收下一个红外遥控信号。 |
---
### 第二十四课 DS1307时钟模块
1.1 项目介绍
这个模块主要用到的芯片是美国DALLAS公司推出的I2C总线接口实时时钟芯片DS1307，它可独立于CPU工作，不受CPU主晶振及其电容的影响；计时准确，月累积误差一般小于10秒。此芯片还具有主电源掉电情况下的时钟保护电路，DS1307的时钟靠后备电池维持工作，拒绝CPU对其读出和写入访问。同时还具有备用电源自动切换控制电路，因而可在主电源掉电和其它一些恶劣环境场合中保证系统时钟的定时准确性。DS1307具有产生秒、分、时、日、月、年等功能，且具有闰年自动调整功能。同时，DS1307芯片内部还集成有一定容量、具有掉电保护特性的静态RAM，可用于保存一些关键数据。
---
1.2 模块参数
中断类型 : 全天时间
存储器容量 : 56 bytes
存储器类型 : RAM
接口类型 : Serial, I2C
时钟频率 : 32.768kHz
特点 : 方波输出
电压, Vcc 最大 : 5V
电源电压 最小 : 4.5V
类型 : RTC
工作温度 ：-10°C ~ +50°C
通讯方式 ：I2C通讯
尺寸 ：47.6 x 23.8 x 9.3 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
DS1307 把8 个寄存器和56 字节的RAM 进行了统一编址，记录年、月、日、时、分、秒及星期; AM、PM 分别表示上午和下午; 56 个字节的NVRAM存放数据; 2线串口; 可编程的方波输出;电源故障检测及自动切换电路;电池电流小于500nA。
主要引脚定义如下：
| DS1307引脚 | 定义 |
| ---------- | -------------------- |
| X1、X2 | 32.768kHz 晶振接入端 |
| VBAT | +3V 电池电压输入 |
| VCC | 电源电压 |
| SQW | 方波驱动器 |
| SCL | 串行时钟 |
| SDA | 串行数据 |
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ----------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes DS1307时钟传感器模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**DS1307.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : DS1307 Real Time Clock
* 功能 : 读取DS1307时钟模块的年/月/日/时/分/秒/周
* 作者 : http://www.keyes-robot.com/
*/
#include
#include "RtcDS1307.h" //DS1307时钟模块库
RtcDS1307 Rtc(Wire);//I2C接口
void setup(){
Serial.begin(57600);//波特率设置为57600
Rtc.Begin();
Rtc.SetIsRunning(true);
Rtc.SetDateTime(RtcDateTime(__DATE__, __TIME__));
}
void loop(){
// 打印年/月/日/小时/分/ 秒/周
Serial.print(Rtc.GetDateTime().Year());
Serial.print("/");
Serial.print(Rtc.GetDateTime().Month());
Serial.print("/");
Serial.print(Rtc.GetDateTime().Day());
Serial.print(" ");
Serial.print(Rtc.GetDateTime().Hour());
Serial.print(":");
Serial.print(Rtc.GetDateTime().Minute());
Serial.print(":");
Serial.print(Rtc.GetDateTime().Second());
Serial.print(" ");
Serial.println(Rtc.GetDateTime().DayOfWeek());
delay(1000);//延迟1秒
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
若代码上传不成功，提示“**RtcDS1307.h: No such file or directory**”，请添加库文件。先点击“**项目**”，选择“**加载库**”，最后选择“**添加.ZIP库**”。
根据库文件的路径打开库文件夹，选中”**Rtc_by_Makuna.zip**“库压缩包，然后单击“**打开**”，库文件成功加入。
再次上传代码，代码上传成功后，拔下USB线断电。
先在模块上安装电池，然后按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**57600**。
串口监视器打印出年、月、日、时、分、秒、周，并每秒刷新一次，显示如下图。
---
1.8 代码说明
| 代码 | 说明 |
| ----------------------------- | -------------------------- |
| Rtc.Begin() | 启动DS1307实时时钟。 |
| Rtc.GetDateTime() | 获取当前系统的时间和日期。 |
| Rtc.SetDateTime() | 设置时间。 |
| Rtc.GetDateTime().Year() | 返回年份。 |
| Rtc.GetDateTime().Month() | 返回月份。 |
| Rtc.GetDateTime().Day() | 返回日期。 |
| Rtc.GetDateTime().Hour() | 返回小时。 |
| Rtc.GetDateTime().Minute() | 返回分钟。 |
| Rtc.GetDateTime().Second() | 返回秒数。 |
| Rtc.GetDateTime().DayOfWeek() | 返回星期。 |
---
### 第二十五课 TM1650四位数码管模块
1.1 项目介绍
Keyes TM1650四位数码管模块选用的 0.36 英寸红色共阴4位数码管的驱动芯片是TM1650。TM1650是一种带键盘扫描接口的LED驱动控制专用电路的芯片。内部集成有MCU输入输出控制数字接口、数据锁存器、LED 驱动、键盘扫描等电路。TM1650性能稳定、质量可靠、抗干扰能力强，可适用于24小时长期连续工作的应用场合。TM1650采用两线串行传输协议通讯（注意：该数据传输协议不是标准的I2C协议）。该芯片只需要通过两个引脚与MCU通讯就可以完成数码管的驱动，可以节省MCU引脚资源。
实验中使用Keyes TM1650四位数码管模块时，我们只需要2根信号线即可使单片机控制4位数码管，大大节约了控制板IO口资源。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 100 mA
最大功率 : 0.5 W
数码管显示颜色 : 红色
LED极性 : 共阴
通讯方式 ：2线高速串行接口（CLK,DAT）
工作温度 ：-10°C ~ +50°C
尺寸 ：47.6 x 23.8 x 10.6 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
TM1650与MCU之间的通讯采用2线高速串行接口（CLK,DAT），这两个连线分别是数据线DAT和同步时钟线CLK。其中DAT为双向数据传输线，TM1650既用该线从MCU接收数据，也用该线向MCU发送数据。
实验中我们使用封装好的库函数。
如果大家有兴趣也可以接着往下学习了解 1.3.1 TM1650通讯时序格式和 1.3.2 指令集说明，然后再去了解底层的库函数是如何实现的。
#1.3.1 TM1650通讯时序格式
TM1650采用下图1 中2线串行传输协议通讯：
（1）开始信号（START）/结束信号(STOP)
开始信号：保持 CLK 为“1”电平，DAT 从“1”跳“0”，认为是开始信号，如上图1的 A 段；
结束信号：保持 CLK 为“1”电平，DAT 从“0”跳“1”，认为是结束信号，如上图1的 E 段；
（2）ACK 信号
如果本次通讯正常，芯片在串行通讯的第 8 个时钟下降沿后，TM1650 主动把 DAT 拉低，直到 CLK 检测到上升沿，DAT 释放为输入状态（对芯片而言）,如上图1的 D 段。
（3） 写“1”和写“0”
写“1”：保持 DAT 为“1”电平，CLK 从“0”跳到“1”,再从“1”跳到“0”，则认为是写入“1” ，如上图 1的 B 段。
写“0”：保持 DAT 为“0”电平，CLK 从“0”跳到“1”,再从“1”跳到“0”，则认为是写入“0” ，如上图 1的 C 段。
（4） 一个字节（8 位）数据传输格式
一个字节数据的传输格式如图上 2，数据发送时 MSB 在前，LSB 在后，即高位先进。微处理器的数据通过 2 线 串行接口和 TM1650 通信，当 CLK 是高电平时，DAT 上的信号必须保持不变；只有 CLK 上的时钟信号为低电平时， DAT 上的信号才能改变。数据输入的开始条件是 CLK 为高电平时，DAT 由高变低；结束条件是 CLK 为高时，DAT 由低电平变为高电平。
（5）写显示操作
ADDRESS：显示地址（68H、6AH、6CH、6EH）；
DATA：显示数据。
（6）完整操作时序
command1：系统命令 48H；
command2：系统参数设置；
ADDRESS：显示地址（68H、6AH、6CH、6EH）；
DATA：显示数据。
备注：
1、设置系统参数和写入显存数据是两个独立的过程，它们之间的顺序不影响实际应用；
2、每次输入系统命令（48H）和系统参数设置命令都会改变系统参数，请特别注意待机指令操作。
#1.3.2 指令集说明
（1）数据命令设置
注意：使用的指令是 16 进制 H，输入数据和读取数据都是从高位开始。
所以在代码中我们数据命令设置为 0x48，使用TM1650点亮数码管的功能，而不使用按键扫描的功能。
（2）显示命令设置
注意：在发送上述系统显示命令前需要先输入系统命令48H,如48H+11H=1级亮度开屏显示。
B[7:0] 这里实际是一个字节数据，只是不同位部分代表不同功能。
B[6:4] ：设置数码管亮度。注意，000 最亮。
B[3] ：设置是否显示小数点。
B[0] ：设置数码管的开屏、关屏。
（3） 显存地址
如果要显示小数点，则必须先需要将段模式设置为 8 段输出。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ----------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes TM1650四位数码管模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Four_digital_tube.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : TM1650 Four digital tube
* 功能 : TM1650四数码管显示0-9999
* 作者 : http://www.keyes-robot.com/
*/
#include "TM1650.h"
#define CLK 22 //TM1650的引脚定义，可以更改为其他端口
#define DIO 21
TM1650 DigitalTube(CLK,DIO);
void setup(){
DigitalTube.setBrightness(); //设置亮度，0- 7，默认值:2
DigitalTube.displayOnOFF(); //显示打开或关闭，0=显示关闭，1=显示打开，默认值:1
for(char b=1;b<5;b++){
DigitalTube.clearBit(b); //清晰显示位
}
// DigitalTube.displayDot(1,true); //Bit0显示点，在displayBit()之前使用
DigitalTube.displayBit(1,0); //DigitalTube.display(bit,number); bit=0~3，number=0~9
}
void loop(){
for(int num=0; num<10000; num++){
displayFloatNum(num);
delay(100);
}
}
void displayFloatNum(float num){
if(num > 9999)
return;
int dat = num*10;
//DigitalTube.displayDot(2,true); //Bit0显示点，在displayBit()之前使用
if(dat/10000 != 0){
DigitalTube.displayBit(1, dat%100000/10000);
DigitalTube.displayBit(2, dat%10000/1000);
DigitalTube.displayBit(3, dat%1000/100);
DigitalTube.displayBit(4, dat%100/10);
return;
}
if(dat%10000/1000 != 0){
DigitalTube.clearBit(1);
DigitalTube.displayBit(2, dat%10000/1000);
DigitalTube.displayBit(3, dat%1000/100);
DigitalTube.displayBit(4, dat%100/10);
return;
}
if(dat%1000/100 != 0){
DigitalTube.clearBit(1);
DigitalTube.clearBit(2);
DigitalTube.displayBit(3, dat%1000/100);
DigitalTube.displayBit(4, dat%100/10);
return;
}
DigitalTube.clearBit(1);
DigitalTube.clearBit(2);
DigitalTube.clearBit(3);
DigitalTube.displayBit(4, dat%100/10);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
若代码上传不成功，提示“**TM1650.h: No such file or directory**”，请添加库文件。先点击“**项目**”，选择“**加载库**”，最后选择“**添加.ZIP库**”。
根据库文件的路径打开库文件夹，选中”**TM1650.zip**“库压缩包，然后单击“**打开**”，库文件成功加入。
再次上传代码，代码上传成功后，拔下USB线断电。按照接线图正确接好模块后再用USB线连接到计算机上电。4位数码管显示数字，从0开始，每100毫秒加1，直至加到9999后又从0开始循环。
---
1.8 代码说明
| 代码 | 说明 |
| --------------------------- | --------------------------------------------------- |
| DigitalTube.setBrightness() | 设置亮度，0- 7，默认值:2 。 |
| DigitalTube.displayOnOFF() | 显示打开或关闭，0=显示关闭，1=显示打开，默认值:1 。 |
| DigitalTube.clearBit(b) | 清除位显示。 |
---
### 第二十六课 HT16K33_8X8点阵模块
1.1 项目介绍
点阵，多个LED组成的阵列，他们的集合称为“阵”，其中单个单元称为“点”。8X8点阵共由64个发光二极管组成，且每个发光二极管是放置在行线和列线的交叉点上。
第二课我们学习了一个IO口控制一个led，这节课我们来学习用更少的IO口控制更多的led。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 200 mA
最大功率 : 1 W
工作温度 ：-10°C ~ +50°C
通讯方式 ：I2C通讯
I2C通信地址 ：0X70
点阵屏显示颜色 ：蓝色
尺寸 ：32 x 23.8 x 9.3 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
如原理图所示，如果想要点亮第一行第一列的LED灯，只需要将C1置高电平、R1置低电平就可以了。如果我们想让第一行led全部点亮，只需要将R1置为低电平，C1~C8全部置为高电平就可以了。原理非常简单，但是这样设置的话我们总共需要用到16个IO口，非常浪费单片机资源。为了节省IO口不浪费单片机资源，我们特别设计了这个HT16K33_8X8点阵模块，利用HT16K33芯片驱动1个8*8点阵，只需要利用单片机的I2C通信端口就能控制点阵的64个发光二极管。
我们这款Keyes HT16K33_8X8点阵模块已经固定了通信地址，地址为0x70。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ---------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes HT16K33_8X8点阵模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**HT16K33_88_dot_matrix.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : 8×8 Dot-matrix Display
* 功能 : 8x8 LED点阵显示“笑脸”图案
* 作者 : http://www.keyes-robot.com/
*/
#include "HT16K33_Lib_For_ESP32.h"
#define SDA 21
#define SCL 22
ESP32_HT16K33 matrix = ESP32_HT16K33();
//亮度值可设置为1 ~ 15，其中1最暗，15最亮
###define A 15
byte result[8][8];
byte test1[8] = {0x00,0x42,0x41,0x09,0x09,0x41,0x42,0x00};
void setup()
{
matrix.init(0x70, SDA, SCL);//初始化矩阵
matrix.showLedMatrix(test1,0,0);
matrix.show();
}
void loop()
{
for (int i = 0; i <= 7; i++)
{
matrix.setBrightness(i);
delay(100);
}
for (int i = 7; i > 0; i--)
{
matrix.setBrightness(i);
delay(100);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.7 实验结果
若代码上传不成功，提示“**HT16K33_Lib_For_ESP32.h: No such file or directory**”，请添加库文件。先点击“**项目**”，选择“**加载库**”，最后选择“**添加.ZIP库**”。
根据库文件的路径打开库文件夹，选中”**HT16K33_Lib_For_ESP32.zip**“库压缩包，然后单击“**打开**”，库文件成功加入。
再次上传代码，代码上传成功后，拔下USB线断电。按照接线图正确接好模块后再用USB线连接到计算机上电。HT16K33_8X8点阵模块显示“笑脸”图案。
若代码上传成功后点阵屏不显示“笑脸”图案，尝试按一下RESET键。
---
1.8 代码说明
点阵上的图案是由一个字节数据类型的数组构成的，我们用下面的表格表示。其中1表示亮，0表示灭，我们可以看到是一个“笑脸”图案。
一列一列来看，可以知道点亮“笑脸”图案的矩阵代码为{0x00,0x42,0x41,0x09,0x09,0x41,0x42,0x00}。
---
### 第二十七课 按键控制LED灯
1.1 项目介绍
从前面的实验课程中我们学习了按键模块，按下按键我们的单片机读取到低电平，松开按键读取到高电平。在这一实验课程中，我们将按键模块和紫色LED模块组合实验，实现按下按键LED点亮，再次按下按键LED熄灭，再次按下再次点亮的效果。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 单路按键模块 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 实验接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**button_control_LED.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : button_control_LED
* 功能 : 做一盏台灯
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_LED 12
#define PIN_BUTTON 13
bool ledState = false;
void setup() {
// 初始化数字引脚PIN_LED作为输出
pinMode(PIN_LED, OUTPUT);
pinMode(PIN_BUTTON, INPUT);
}
// 循环函数会一直运行下去
void loop() {
if (digitalRead(PIN_BUTTON) == LOW) {
delay(20);
if (digitalRead(PIN_BUTTON) == LOW) {
reverseGPIO(PIN_LED);
}
while (digitalRead(PIN_BUTTON) == LOW);
}
}
void reverseGPIO(int pin) {
ledState = !ledState;
digitalWrite(pin, ledState);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电。按下按键，LED点亮，再次按下，LED熄灭。循环进行。
---
1.6 代码说明
| 代码 | 说明 |
| -------------------------------------- | ------------------------------------------------------------ |
| bool ledState = false | 布尔型（bool）变量的值只有真 （true) 和假 （false）。 C++中如果值非零就为True,为零就是False。这里可以知道ledState初始值为0。 |
| ledState = !ledState | 将ledState的当前值取反后再赋值给ledState本身。 |
| delay(20) | 这里延时的作用是软件方法消抖。按键机械触点断开、闭合时，由于触点的弹性作用，按键开关不会马上稳定接通或一下子断开，在闭合及断开的瞬间均伴随有一连串的抖动，为了不产生这种现象而作的措施就是按键消抖。代码中检测出键闭合后执行一个延时程序，20ms的延时，让前沿抖动消失后再一次检测键的状态，如果仍保持闭合状态电平，则确认为真正有键按下。 |
| while (digitalRead(PIN_BUTTON) == LOW) | 循环PIN_BUTTON) == LOW，直至松开按键跳出while循环。作用是按下按键不松开时LED保持当前状态。若没有while循环，ledState会不断取反，也就是LED灯会不断地快速亮灭。 |
---
### 第二十八课 障碍物报警实验
1.1 项目介绍
在前面实验课程中中，我们使用一个输入模块控制另一个输出模块。在这一实验中，我们还是用一个模块控制另一个模块。
生活中，我们可以利用一个检测传感器控制一个有源蜂鸣器响起或者LED点亮，做声光报警设备，如检测磁场（干簧管）、检测倾斜（倾斜模块）等等。这一实验课程中我们将避障传感器和有源蜂鸣器模块组合实验，实现避障传感器检测到障碍物时有源蜂鸣器响起的效果。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 避障传感器 x1 | Keyes 有源蜂鸣器模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 实验接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Avoiding_alarm.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Avoiding alarm
* 功能 : 避障传感器控制蜂鸣器
* 作者 : http://www.keyes-robot.com/
*/
int item = 0;
void setup() {
pinMode(12, INPUT); //避障传感器连接GPIO12，设置为输入模式
pinMode(13, OUTPUT); //将蜂鸣器连接到GPIO13上并设置为输出模式
}
void loop() {
item = digitalRead(12);//读取避障传感器输出的电平值
if (item == 0) {//障碍物检测
digitalWrite(13, HIGH);//蜂鸣器响起
} else { //未检测到障碍物
digitalWrite(13, LOW); //蜂鸣器关闭
}
delay(100);//延迟100ms
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电。当避障传感器检测到障碍物时，避障传感器上SLED灯亮起，同时有源蜂鸣器发出声响；当避障传感器检测不到障碍物时，有源蜂鸣器停止发出声响。
---
1.6 代码说明
| 代码 | 说明 |
| ---------------------- | ------------------------ |
| item == 0 | 避障传感器检测到障碍物。 |
| digitalWrite(13, HIGH) | 有源蜂鸣器发出声响。 |
| digitalWrite(13, LOW) | 有源蜂鸣器停止发出声响。 |
---
### 第二十九课 入侵检测报警器
1.1 项目介绍
上一课实验中我们学习了使用避障传感器检测障碍物进行报警提醒。在这一实验课程中我们将人体红外热释传感器、紫色LED模块和有源蜂鸣器模块组合实验，实现人体红外热释传感器检测到附近有人经过时有源蜂鸣器响起，紫色LED快速闪烁的效果。
---
1.2 实验组件
|  |  |  |
| ------------------------ | ---------------------------- | ------------------------ |
| ESP32 Plus主板 x1 | Keyes 人体红外热释传感器 x1 | Keyes 有源蜂鸣器模块 x1 |
|  |  |  |
| Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x3 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**PIR_alarm.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : PIR alarm
* 功能 : PIR控制蜂鸣器
* 作者 : http://www.keyes-robot.com/
*/
int item = 0;
void setup() {
pinMode(12, INPUT); //PIR运动传感器连接GPIO12，设置为输入模式
pinMode(13, OUTPUT); //将主用蜂鸣器连接到GPIO13上，并设置为输出模式
pinMode(5, OUTPUT); //将LED连接到GPIO5上，并设置为输出模式
}
void loop() {
item = digitalRead(12);//读取红外热释传感器输出的数字液位信号
if (item == 1) { //运动检测
digitalWrite(13, HIGH); //打开蜂鸣器
digitalWrite(5, HIGH); //打开LED
delay(200);//延迟 200ms
digitalWrite(13, LOW); //关掉蜂鸣器
digitalWrite(5, LOW); //关闭LED
delay(200);//延迟 200ms
} else { //没有检测到任何信号或数据
digitalWrite(13, LOW); //关掉蜂鸣器
digitalWrite(5, LOW); //关闭LED
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电。当人体红外热释传感器检测到附近有人经过时，人体红外热释传感器上的红灯灭，有源蜂鸣器发出警报，紫色LED灯快速闪烁。
---
1.6 代码说明
| 代码 | 说明 |
| ---------------------- | ---------------------------------------- |
| item = digitalRead(12) | 人体红外热释传感器读取数字电平信号输出。 |
| item == 1 | 运动检测，检测到有人经过。 |
| digitalWrite(13, HIGH) | 有源蜂鸣器响起发出警报。 |
| digitalWrite(5, HIGH) | 紫色LED灯快速闪烁。 |
---
### 第三十课 旋转编码器控制RGB
1.1 项目介绍
在第二十课的实验中我们学习了使用旋转编码器计数。在这一实验课程中我们将旋转编码器模块和共阴RGB模块组合实验，通过旋转编码器计数的结果，控制RGB模块上LED显示不同的颜色。
---
1.2 实验组件
|  |  |  |
| ---------------------------- | ---------------------------- | ------------------------ |
| ESP32 Plus主板 x1 | Keyes 旋转编码器模块 x1 | Keyes 共阴RGB模块 x1 |
|  |  |  |
| XH2.54-5P 转杜邦线母单线 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Encoder_control_RGB.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Encoder control RGB
* 功能 : 旋转编码器控制RGB来呈现不同的效果
* 作者 : http://www.keyes-robot.com/
*/
//旋转编码器接口
int Encoder_DT = 27;
int Encoder_CLK = 14;
int Encoder_Switch = 16;
int Previous_Output;
int Encoder_Count;
int ledPins[] = {32, 4, 2}; //定义红色，绿色，蓝色引脚
const byte chns[] = {0, 1, 2}; //定义PWM通道
int red, green, blue;
int val;
void setup() {
Serial.begin(9600);
//引脚模式声明
pinMode (Encoder_DT, INPUT);
pinMode (Encoder_CLK, INPUT);
pinMode (Encoder_Switch, INPUT);
Previous_Output = digitalRead(Encoder_DT); //读取输出DT的初始值
for (int i = 0; i < 3; i++) { //设置pwm通道，1KHz,8bit
ledcSetup(chns[i], 1000, 8);
ledcAttachPin(ledPins[i], chns[i]);
}
}
void loop() {
if (digitalRead(Encoder_DT) != Previous_Output)
{
if (digitalRead(Encoder_CLK) != Previous_Output)
{
Encoder_Count ++;
Serial.print(Encoder_Count);
Serial.print(" ");
val = Encoder_Count % 3;
Serial.println(val);
}
else
{
Encoder_Count--;
Serial.print(Encoder_Count);
Serial.print(" ");
val = Encoder_Count % 3;
Serial.println(val);
}
}
Previous_Output = digitalRead(Encoder_DT);
if (digitalRead(Encoder_Switch) == 0)
{
delay(5);
if (digitalRead(Encoder_Switch) == 0) {
Serial.println("Switch pressed");
while (digitalRead(Encoder_Switch) == 0);
}
}
if (val == 0) {
//红色(255, 0, 0)
ledcWrite(chns[0], 255 );
ledcWrite(chns[1], 0);
ledcWrite(chns[2], 0);
} else if (val == 1) {
//绿色(0, 255, 0)
ledcWrite(chns[0], 0);
ledcWrite(chns[1], 255);
ledcWrite(chns[2], 0);
} else {
//蓝色(0, 0, 255)
ledcWrite(chns[0], 0);
ledcWrite(chns[1], 0);
ledcWrite(chns[2], 255);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
任意方向旋转编码器，串口监视器打印出对应余数；RGB模块上的LED显示余数对应的颜色：余数0显示红色、余数1显示绿色、余数2显示蓝色。按下旋转编码器，RGB模块上LED保持当前颜色不变。
---
1.6 代码说明
| 代码 | 说明 |
| ------------------------------------ | ------------------------------------------------------------ |
| ous_Output = digitalRead(Encoder_DT) | 读取输出DT的初始值。 |
| ledcSetup(chns[i], 1000, 8) | 设置pwm通道，1KHz,8bit。 |
| al = Encoder_Count % 3 | %是模除运算符。代码中模除的结果是旋转编码器计数的值与3相除的余数。 |
---
### 第三十一课 电位器调节灯光亮度
1.1 项目介绍
从前面的课程实验中我们学习了设计呼吸灯和按键控制LED灯。在这一实验课程中我们尝试将呼吸灯和按键控制LED灯这两个实验现象组合起来，用可调电位器代替按键，实现利用旋转可调电位器读取到的模拟值控制紫色LED亮度的效果。可调电位器模拟值的范围是0 ~ 4095；LED的亮度由PWM值控制，范围为0 ~ 255。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------- | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 旋转电位器传感器 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**adjust_the_light.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : adjust the light
* 功能 : 通过电位器控制LED的亮度
* 作者 : http://www.keyes-robot.com/
*/
#define PIN_ANALOG_IN 34 //电位器的引脚
#define PIN_LED 5 // LED的引脚
#define CHANNEL 0 // 使用led通道0
void setup() {
ledcSetup(CHANNEL, 1000, 12); // PWM取值范围为0 ~ 4096
ledcAttachPin(PIN_LED, CHANNEL); // PIN_LED引脚定义为通道0的输出引脚
}
void loop() {
ledcWrite(CHANNEL, analogRead(PIN_ANALOG_IN)); // 设置累计脉冲宽度
delay(10);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电。旋转电位器，可以调节紫色LED的亮度。
---
1.6 代码说明
| 代码 | 说明 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| double ledcSetup(uint8_t chan, double freq, uint8_t bit_num) | 第一个参数 chan 表示通道号，取值为0 ~ 15即可设置16个通道，其中高速通道（0 ~ 7）由80MHz时钟驱动，低速通道（8 ~ 15）由 1MHz 时钟驱动；第二个参数 freq 为期望设置的频率；第三个参数为占空比分辨率的计数位数，其取值为0 ~ 20（该值决定后面 ledcWrite 函数中占空比可写值，比如该值写10，那么PWM的刻度范围就是0 ~ 2^10^，也就是0 ~ 1024，则占空比最大可写1023（2^10^ - 1） 即占空比范围为0 ~ 1023）。 |
| ledcSetup(CHANNEL, 1000, 12) | 从上面的ledcSetup()函数的原型说明我们可以知道实验中使用ledc通道0。设置频率为1000 Hz。分辨率为12位，那么PWM刻度范围就是0 ~ 2^12^，也就是0 ~ 4096，占空比范围为0 ~ 4095（）。 |
| ledcAttachPin(PIN_LED, CHANNEL) | PIN_LED引脚（IO 4）定义为通道0的输出引脚。 |
| ledcWrite(CHANNEL, analogRead(PIN_ANALOG_IN) | 设置ledc通道0的输出占空比。将可调电位器读取到的模拟值（范围是0 ~ 4095）设置为ledc通道0（范围是0 ~ 4095）的输出占空比，控制紫色LED的亮度。 |
---
### 第三十二课 声控灯
1.1 项目介绍
如今智能家居发展迅速，你使用过智能家居当中的智能声控灯吗？当我们跺跺脚或者拍拍手时，智能声控灯自动亮起；当没有声音时，智能声控灯处于熄灭状态。智能声控灯上安装有声音探测传感器，这些传感器将外界声音的大小，转换成对应数值。智能声控灯设置一个临界点，当声音转换后对应的数值超过该临界点时，灯光亮起一段时间。
在这一实验课程中，我们将声音传感器和紫色LED模块组合实验，学习制作一个最简单的智能声控灯。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 声音传感器 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**sound-controlled_lights.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : sound-controlled lights
* 功能 : 声音传感器控制LED开关
* 作者 : http://www.keyes-robot.com/
*/
int ledPin = 5; //LED连接到GPIO5
int microPin = 34; //声音传感器连接到GPIO34
void setup() {
Serial.begin(9600); //波特率设置为9600
pinMode(ledPin, OUTPUT); //LED为输出模式
}
void loop() {
int val = analogRead(microPin); //读取模拟值
Serial.print(val); // 串口打印
if(val > 400){ //超过阈值
digitalWrite(ledPin, HIGH); //LED亮3s，并打印相应信息
Serial.println(" led on");
delay(3000);
}else{ //否则
digitalWrite(ledPin, LOW); //关闭LED并打印相应信息
Serial.println(" led off");
}
delay(100);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
串口监视器打印出声音传感器接收到的声音对应的ADC值，接收到的声音增大时ADC值也增大，当ADC值大于400时，LED模块上LED亮起3秒，然后熄灭。
---
1.6 代码说明
| 代码 | 说明 |
| ------------------------------ | ------------------ |
| int val = analogRead(microPin) | 读取模拟值。 |
| Serial.print(val) | 串口打印出模拟值。 |
---
### 第三十三课 超声波雷达
1.1 项目介绍
蝙蝠飞行与获取猎物是通过回声定位的。回声定位：某些动物能通过口腔或鼻腔把从喉部产生的超声波发射出去，利用折回的声音来定向，这种空间定向的方法称为回声定位。科学家们从蝙蝠身上得到的启示发明了雷达，即雷达的天线相当于蝙蝠的嘴,而天线发出的无线电波就相当于蝙蝠的超声波,雷达接收电波的荧光屏就相当于蝙蝠的耳朵。
这一课我们就来学习制作一个简易雷达。将HC-SR04 超声波传感器、8002b功放 喇叭模块、共阴RGB模块和TM1650四位数码管模块组合实验，利用距离大小控制功放喇叭模块模块响起对应频率的声音、RGB亮起对应颜色，然后把这个距离显示在四位数码管上。这样就搭建好了一个简易的超声波雷达系统。
---
1.2 实验组件
|  |  |  |
| ---------------------------- | ---------------------------- | ----------------------------- |
| ESP32 Plus主板 x1 | HC-SR04 超声波传感器 x1 | Keyes 超声波转接模块 x1 |
|  |  |  |
| Keyes 8002b功放 喇叭模块 x1 | Keyes 共阴RGB模块 x1 | Keyes TM1650四位数码管模块 x1 |
|  |  |  |
| XH2.54-3P 转杜邦线母单线 x1 | XH2.54-4P 转杜邦线母单线 x3 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**/home/pi/代码**”中，我们可以在此路径下打开代码文件''**Ultrasonic_radar.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Ultrasonic radar
* 功能 : 超声波控制四位数管，蜂鸣器和RGB灯模拟超声波雷达
* 作者 : http://www.keyes-robot.com/
*/
#include "TM1650.h" //导入TM1650库文件
//接口为GPIO21和GPIO22
#define DIO 21
#define CLK 22
TM1650 DigitalTube(CLK,DIO);
#define BUZZER_PIN 2 //定义喇叭引脚为GPIO2
int TrigPin = 13; //设置Trig引脚为GPIO13
int EchoPin = 12; //设置Echo引脚为GPIO12
int distance; //超声波测量距离
int ledPins[] = {4, 32, 33}; //定义红色，绿色，蓝色引脚
const byte chns[] = {0, 1, 2}; //定义PWM通道
float checkdistance() { //得到的距离
// 事先给一个短的低电平，以确保一个干净的高脉冲;
digitalWrite(TrigPin, LOW);
delayMicroseconds(2);
// 传感器由10微秒或更长时间的高脉冲触发
digitalWrite(TrigPin, HIGH);
delayMicroseconds(10);
digitalWrite(TrigPin, LOW);
// 从传感器读取信号:一个高电平脉冲
// 它的持续时间是从发送ping命令到从对象接收回显的时间(以微秒为单位)
float distance = pulseIn(EchoPin, HIGH) / 58.00; //转换成距离
delay(300);
return distance;
}
void setup() {
pinMode(BUZZER_PIN, OUTPUT); // 设置蜂鸣器为输出模式
ledcSetup(3, 660, 13); //设置pwm通道，660Hz,13bit
ledcAttachPin(BUZZER_PIN, 3);
DigitalTube.setBrightness(); //设置亮度，0- 7，默认值:2
DigitalTube.displayOnOFF(); //显示打开或关闭，0=显示关闭，1=显示打开，默认值:1
for(char b=1;b<5;b++){
DigitalTube.clearBit(b); //DigitalTube.clearBit(0 to 3); 清空位显示
}
DigitalTube.displayBit(1,0); //DigitalTube.Display(bit,number); bit= 0 - 3，number= 0 - 9
pinMode(TrigPin, OUTPUT); //设置Trig引脚作为输出
pinMode(EchoPin, INPUT); //设置Echo引脚作为输入
for (int i = 0; i < 3; i++) { //设置pwm通道，1KHz,8bit
ledcSetup(chns[i], 1000, 8);
ledcAttachPin(ledPins[i], chns[i]);
}
}
void loop() {
distance = checkdistance();//超声波测距
displayFloatNum(distance); //数码管显示距离
if (distance <= 10) {
ledcWrite(3, 50);
delay(10);
ledcWrite(chns[0], 255); //共阴LED，高电平开启LED
ledcWrite(chns[1], 0);
ledcWrite(chns[2], 0);
} else if (distance > 10 && distance <= 20) {
ledcWrite(3, 0);
ledcWrite(chns[0], 0);
ledcWrite(chns[1], 255);
ledcWrite(chns[2], 0);
} else {
ledcWrite(3, 0);
ledcWrite(chns[0], 0);
ledcWrite(chns[1], 0);
ledcWrite(chns[2], 255);
}
}
void displayFloatNum(float distance){
if(distance > 9999)
return;
int dat = distance*10;
//DigitalTube.displayDot(2,true); //Bit0 显示点。在displayBit()之前使用。
if(dat/10000 != 0){
DigitalTube.displayBit(0, dat%100000/10000);
DigitalTube.displayBit(1, dat%10000/1000);
DigitalTube.displayBit(2, dat%1000/100);
DigitalTube.displayBit(3, dat%100/10);
return;
}
if(dat%10000/1000 != 0){
DigitalTube.clearBit(0);
DigitalTube.displayBit(1, dat%10000/1000);
DigitalTube.displayBit(2, dat%1000/100);
DigitalTube.displayBit(3, dat%100/10);
return;
}
if(dat%1000/100 != 0){
DigitalTube.clearBit(0);
DigitalTube.clearBit(1);
DigitalTube.displayBit(2, dat%1000/100);
DigitalTube.displayBit(3, dat%100/10);
return;
}
DigitalTube.clearBit(0);
DigitalTube.clearBit(1);
DigitalTube.clearBit(2);
DigitalTube.displayBit(3, dat%100/10);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电。
当超声波传感器检测到障碍物距离范围在10cm 以内时，RGB LED灯亮红色，并将检测到障碍物的距离显示在四位数码管上。同时8002b功放 喇叭模块发出声响，起到提示的作用。
当超声波传感器检测到障碍物距离范围在10cm ~ 20cm 以内时，RGB LED灯亮绿色，并将检测到障碍物的距离显示在四位数码管上。
当超声波传感器检测到障碍物距离范围在20cm 以外时，RGB LED灯亮蓝色，并将检测到障碍物的距离显示在四位数码管上。
---
1.6 代码说明
| 代码 | 说明 |
| ------------------------------------------------ | ---------------------------------------------- |
| digitalWrite(TrigPin, LOW); delayMicroseconds(2) | 事先给一个短的低电平，以确保一个干净的高脉冲。 |
---
### 第三十四课 红外遥控灯
1.1 项目介绍
在前面实验中，我们学会了点亮或熄灭LED、学会了利用PWM调节灯光的亮度、学会了使用红外接收模块，并将接收到的遥控器对应的键值打印出来。在这一实验课程中，我们将红外接收模块和紫色LED模块组合实验，实现用红外遥控器控制紫色LED的亮灭以及控制紫色LED显示不同亮度。
当红外接收模块接收到红外遥控器的按键值时，通过设置此按键值的输出PWM值实现设置不同LED亮度的效果，控制LED的亮灭也一样。
在这一实验课程中我们使用 “①“、”②“、”③”三个按键来控制紫色LED实现弱亮、正常亮、强亮三种不同亮度。如果想要使用 “OK” 键这一个按键来控制LED亮和灭的两种情况该如何实现呢？这一实验课程我们将学习使用一个新的基本数据类型 —— boolean，来实现同一个按键控制LED亮灭的效果。
**boolean 数据类型**，变量存储为 8位（1 个字节）的数值形式，**只能是 True 或是 False**。boolean 变量的值显示为 True 或 False（在使用 Print 的时候），或者 #TRUE# 或 #FALSE#（在使用 Write # 的时候）。使用关键字True 与 False 可将 boolean 变量赋值为这两个状态中的一个。
设置代码，按下“OK”键且满足某一条件，点亮LED；按下“OK”键且满足另一条件，熄灭LED。这个条件我们用 boolean 来实现是最简单方便的，因为 boolean 只有 True 或是 False 两种状态。我们只需要设置按下“OK”键的同时 flag 为 true，即可点亮LED；同理按下“OK”键的同时 flag 为 false，熄灭LED。
---
1.2 实验组件
|  |  |  |
| -------------------------------- | ---------------------------- | ------------------------ |
| ESP32 Plus主板 x1 | Keyes 红外接收模块 x1 | Keyes 紫色LED模块 x1 |
|  |  |  |
| Keyes 遥控器 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**IR_control_LED.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : IR Control LED
* 功能 : 红外遥控LED开关
* 作者 : http://www.keyes-robot.com/
*/
#include
#include
#include
#include
const uint16_t recvPin = 35; // 红外接收GPIO35
IRrecv irrecv(recvPin); // 创建一个用于接收类的类对象
decode_results results; // 创建一个解码结果类对象
int led = 5;//LED连接到GPIO5
boolean flag = true; //LED标志钻头
void setup() {
Serial.begin(9600);
irrecv.enableIRIn(); //启动接收器
pinMode(led, OUTPUT);
ledcSetup(0, 1000, 8);//设置PWM通道
ledcAttachPin(5, 0); //将led引脚连接到PWM通道
}
void loop() {
if(irrecv.decode(&results)) { // 等待解码
serialPrintUint64(results.value, HEX);// 输出解码结果
Serial.print("");
handleControl(results.value); // 处理来自远程控制的命令
irrecv.resume(); // 接收下一个值
}
}
void handleControl(unsigned long value){
if (value == 0xFF02FD && flag == true){ // 接收数字“OK”
ledcWrite(0, 170); //打开LED
delay(10);
Serial.println(" led on");
flag = false;
}
else if (value == 0xFF02FD && flag == false){ // 接收数字“OK”
ledcWrite(0, 0); //打开LED
delay(10);
Serial.println(" led off");
flag = true;
}
else if(value == 0xFF6897){
ledcWrite(0, 85);
Serial.println(" weak light");
delay(10);
}
else if(value == 0xFF9867){
ledcWrite(0, 170);
delay(10);
Serial.println(" normal light");
}
else if(value == 0xFFB04F){
ledcWrite(0, 255);
delay(10);
Serial.println(" strong light");
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
第一次按下红外遥控器上的 “**OK**” 键，紫色LED被点亮，实现开灯的效果。串口监视器打印出按下的按键值和LED灯的亮灭情况：“**FF02FD led on**” 。
再次按下红外遥控器上的 “**OK**” 键，紫色LED熄灭，实现关灯的效果。串口监视器打印出按下的按键值和LED灯的亮灭情况：“**FF02FD led off**” 。
按下红外遥控器上的 “**①**” 键，紫色LED被设置为弱亮。串口监视器打印出按下的按键值和LED灯的亮灭情况：“**FF6897 weak light**” 。
按下红外遥控器上的 “**②**” 键，紫色LED被设置为正常亮。串口监视器打印出按下的按键值和LED灯的亮灭情况：“**FF9867 normal light**” 。
按下红外遥控器上的 “**③**” 键，紫色LED被设置为强亮。串口监视器打印出按下的按键值和LED灯的亮灭情况：“**FFB04F strong light**” 。
---
1.6 代码说明
| 代码 | 说明 |
| ------------------- | ------------------------------------------------------------ |
| boolean flag = true | 设置一个变量 flag 为 boolean 数据类型，数值为 true。 |
| flag = false | boolean 数据类型的 flag 赋值为 false ，以便再次按下再次按下 “OK”键时满足熄灭LED的条件。 |
---
### 第三十五课 Bluetooth
1.1 项目介绍
ESP32是一系列低成本，低功耗的单片机微控制器，集成了Wi-Fi和双模蓝牙。ESP32 可作为独立系统运行应用程序或作为主机 MCU 的从设备，通过 SPI / SDIO 或 I2C / UART 接口提供 Wi-Fi 和蓝牙功能。
蓝牙是一种短距离通信系统，其简单的数据传输有两种模式：主设备工作模式和从设备工作模式。蓝牙技术规定每一对设备之间进行蓝牙通讯时，必须一个为**主端**，另一个为**从端**，才能进行通信。通信时，必须由主端进行查找，发起配对，建链成功后，双方即可收发数据。
- **主设备工作模式** ：主设备是能够搜索并**主动建立连接**的一方，从扫描状态转化而来的。其可以和一个或多个从设备进行连接通信，它会**定期的扫描**周围的广播状态设备发送的广播信息，可以对周围设备进行搜索并选择所需要连接的从设备进行配对连接，**建立通信链路成功后，主从双方就可以发送接收数据**。例如智能手机，数据传输中做主机的蓝牙模块。
**一个蓝牙设备以主模式发起连接时，需要知道从设备的地址，配对密码等信息，配对完成后，可直接连接。**同时主设备可以**设置默认连接**从设备的地址，这样主设备模块上电会自动搜索该地址的从设备并且进行连接。并且**支持白名单功能**，用户只需要把需要连接的设备的地址写入白名单中，模块搜索到符合白名单的设备时就进行连接。主从透传协议相同时，用户不需要关注串口数据与无线数据包之间的数据转换过程，只需通过简单的参数设置，即可实现主设备串口与从设备串口之间的数据透传。
为保证连接的稳定性，预防断电、信号等异常问题导致模块之间断开连接，可以开启断线重连功能，当异常干扰问题消失，模块工作环境恢复正常，主设备会自动搜索刚刚断连的从设备，尽可能减少数据的丢失，提高系统稳定性。
- **从设备工作模式** ：从设备模式是从广播者模式转化而来的，未被连接的从设备首先进入广播状态，**等待被主机搜索**。当从设备被主机扫描到并**建立连接后**，就可以和主机设备**进行数据的收发**。从设备**不能主动建立连接**。从设备模式的蓝牙模块是可以被连接的，定期的和主机进行连接和数据传输，在数据传输过程中作从机。例如蓝牙手表手环，蓝牙鼠标等工作在从设备模式。
一对一应用中从设备可以设为两种类型。一是静默状态，即只能与指定的主设备通信，不被别的蓝牙设备查找；二是开发状态，既可被指定主设备查找，也可以被别的蓝牙设备查找后建立连接。
当手机与ESP32进行数据交换时，**手机通常处于主设备工作模式，ESP32为从设备工作模式。**
这一实验课程我们先学习利用ESP32的蓝牙功能与手机进行简单的数据传输，然后学习用蓝牙控制LED灯的亮灭。
---
1.2 实验组件
在本课程中，我们需要使用一个名为"串行蓝牙终端"的蓝牙应用程序来协助实验。
点击安装：[https://www.appsapk.com/serial-bluetooth-terminal/](https://www.appsapk.com/serial-bluetooth-terminal/)
|  |  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- | -------------------------------------------- |
| ESP32 Plus主板 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 | "串行蓝牙终端"应用程序 |
---
1.3 实验
**1.3.1 实验①：**
（1）实验接线图
（2）实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Classic_Bluetooth.ino**"。
```c++
/*
* 名称 : Classic Bluetooth
* 功能 : ESP32通过蓝牙与手机通信，并通过串口打印手机数据
* 作者 : http://www.keyes-robot.com/
*/
#include "BluetoothSerial.h"
BluetoothSerial SerialBT;
String buffer;
void setup() {
Serial.begin(115200);
SerialBT.begin("ESP32test"); //蓝牙设备名称
Serial.println("\nThe device started, now you can pair it with bluetooth!");
}
void loop() {
if (Serial.available()) {
SerialBT.write(Serial.read());
}
if (SerialBT.available()) {
Serial.write(SerialBT.read());
}
delay(20);
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
（3）实验结果
代码上传成功后，打开串口监视器，设置波特率为**115200**。当串口监视器打印出如下图所示的内容时表示ESP32的蓝牙功能已就绪，等待与手机连接。
**注意：如果打开串口监视器且设置好波特率，串口监视器窗口还是没有显示任何信息，可以尝试按下ESP32的RESET按键。**
确保你的手机已经打开蓝牙且已安装“串口蓝牙终端”应用程序。搜索附近的蓝牙设备，选择 “ESP32test” 进行连接。
出现蓝牙配对请求，选择“**配对**”。
配对成功。
打开“串口蓝牙终端”应用程序，单击图示箭头所指地方。选择 "**Devices**"。
选择经典蓝牙模式下的"**ESP32test**"。
出现连接的成功提示，现在ESP32与你的手机已经建链成功了，可以在ESP32与你的手机之间传输数据了。
先来尝试一下主设备传输数据到从设备。
在“串口蓝牙终端”应用程序发送框内输入 “Hello！” 并发送。ESP32接收成功，在串口监视器打印出接收到的信息。
接下来尝试一下从设备传输数据到主设备。
在串口监视器的输入框内输入 “Hi！” 并发送。手机蓝牙接收成功，在“串口蓝牙终端”应用程序内打印出接收到的信息。
---
**1.3.1 实验②：**
（1）实验接线图
（2）实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Bluetooth_Control_LED.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Bluetooth Control LED
* 功能 : 手机通过蓝牙控制esp32的led
当手机发送“LED_on”时，ESP32的LED灯就会打开。
当手机发送“LED_off”时，ESP32的LED灯就会关闭。
* 作者 : http://www.keyes-robot.com/
*/
#include "BluetoothSerial.h"
#include "string.h"
#define LED 5
BluetoothSerial SerialBT;
char buffer[20];
static int count = 0;
void setup() {
pinMode(LED, OUTPUT);
SerialBT.begin("ESP32test"); //蓝牙设备名称
Serial.begin(115200);
Serial.println("\nThe device started, now you can pair it with bluetooth!");
}
void loop() {
while(SerialBT.available())
{
buffer[count] = SerialBT.read();
count++;
}
if(count>0){
Serial.print(buffer);
if(strncmp(buffer,"led_on",6)==0){
digitalWrite(LED,HIGH);
}
if(strncmp(buffer,"led_off",7)==0){
digitalWrite(LED,LOW);
}
count=0;
memset(buffer,0,20);
}
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口 **。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
（3）实验结果
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**115200**。
参照 **1.3.1 实验①** 的内容，确保蓝牙已配对。在串行蓝牙终端的蓝牙应用程序上发送 "**led_on**" 实现紫色LED灯亮的效果。串口监视器打印出 “**led_on**”。
在串行蓝牙终端的蓝牙应用程序上发送 "**led_off**" 实现紫色LED灯灭的效果。串口监视器打印出 “**led_off**”。
**注意：**如果发送的内容不是 "**led_on**“ 或 "**led_off**"，那么LED的当前状态不会被改变。如当LED亮时，接收到不相关内容时，LED保持亮的状态；当LED灭时，接收到不相关内容时，LED保持灭的状态。
---
1.6 代码说明
| 代码 | 说明 |
| ------------------------------------------------------- | ------------------------------------------------------------ |
| SerialBT.begin("ESP32test") | 设置蓝牙设备的名称。 |
| SerialBT.read() | 读取手机发送的数据。 |
| int strncmp(const char str1, const char str2, size_t n) | 把 str1 和 str2 进行比较，最多比较前 n 个字节。 |
| strncmp(buffer,"led_on",6) | 把 buffer 的前6个字节和 “led_on” 进行比较。 |
| void memset(void ptr, int value, size_t num) | 复制 value 的值到 ptr 所指向的字符串的前 num 个字节。ptr：指向任意类型的指针，即指向我们需要修改的对象，譬如传进来一个数组首地址buff。value：赋给ptr所指对象的值。num:确定将ptr所指的对象中的num个字节全都用value代替。 |
| memset(buffer,0,20) | 复制字符 “0” 到参数 buffer 所指向的字符串的前20个字节全部用 “0” 替代。 |
---
### 第三十六课 WiFi Station Mode
1.1 项目介绍
ESP32有3种不同的WiFi工作模式：
- Station模式（作为WiFi设备主动连接路由器，也叫做WiFi Client）
- AP模式（作为一个Access Point，让其他WiFi设备来连接）即WiFi热点
- Station+AP共存模式（ESP32连接路由器的同时自身也是一个热点供其他WiFi设备来连接）
所有WiFi编程项目在使用WiFi前必须配置WiFi运行模式，否则无法使用WiFi。在这节实验课程中，我们将学习使用ESP32的WiFi Station模式。
**Station 模式：**
当ESP32选择Station模式时，它作为一个WiFi客户端。它可以连接路由器网络，通过WiFi连接与路由器上的其他设备通信。如下图所示，PC和路由器已经连接，ESP32如果要与PC通信，需要将PC和路由器连接起来。
---
1.2 实验组件
|  |  |
| ------------------------ | --------------------- |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**WiFi_Station_Mode.ino**"。
路由器的SSID是无线网的无线名称。SSID是 ServiceSetldentifier 的缩写，意思是:服务集标识。SSID技术可以将一个无线局域网分为几个需要不同身份验证的子网络，每一个子网络都需要独立的身份验证，只有通过身份验证的用户才可以进入相应的子网络，防止未被授权的用户进入本网络。所以在代码运行之前，需要配置 WiFi 名称和密码，将其修改为你自己使用的WiFi 名称和密码，如下图所示。
```c++
/*
* 名称 : WiFi Station Mode
* 功能 : 使用ESP32连接到路由器
* 作者 : http://www.keyes-robot.com/
*/
#include //包含ESP32的WiFi Library头文件
//请输入正确的路由器名称和密码
const char *ssid_Router = "ChinaNet_2.4G"; //输入路由器名称
const char *password_Router = "ChinaNet@233"; //输入路由器密码
void setup(){
Serial.begin(115200);
delay(2000);
Serial.println("Setup start");
WiFi.begin(ssid_Router, password_Router);//将ESP32设置为站模式并将其连接到路由器
Serial.println(String("Connecting to ")+ssid_Router);
//每0.5s检查ESP32与路由器连接是否成功
while (WiFi.status() != WL_CONNECTED){
delay(500);
Serial.print(".");
}
Serial.println("\nConnected, IP address: ");
Serial.println(WiFi.localIP());//串口监视器输出分配给ESP32的IP地址
Serial.println("Setup End");
}
void loop() {
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，打开串口监视器，设置波特率为**115200**。
开始连接，串口监视器打印出“**Connecting to ChinaNet_2.4G**” 提示正在连接到路由器的SSID，当ESP32成功连接到路由器的 SSID 时，串行监视器将打印出 WiFi 分配给ESP32的**IP地址**。
**注意：如果打开串口监视器且设置好波特率，串口监视器窗口还是没有显示任何信息，可以尝试按下ESP32的RESET按键。**
---
1.6 代码说明
| 代码 | 说明 |
| ---------------------------------------- | ------------------------------------------------------------ |
| WiFi.begin(ssid_Router, password_Router) | 连接初始化连接。ssid_Router为 WiFi 名称，password_Router为连接 WiFi 所用的密码。 |
| WiFi.status() | 调用完成后，wifi并不会立即就连接上。此接口函数的作用就是检查wifi是否已经连接上。当返回值为WL_CONNECTED时表示已经连接上。该函数还有其它返回值，表示wifi连接失败等情况。 |
| WiFi.localIP() | 显示本机ip。 |
---
### 第三十七课 WiFi AP Mode
1.1 项目介绍
从上一课实验中我们知道ESP32有3种不同的WiFi工作模式：
- Station模式（作为WiFi设备主动连接路由器，也叫做WiFi Client）
- AP模式（作为一个Access Point，让其他WiFi设备来连接）即WiFi热点
- Station+AP共存模式（ESP32连接路由器的同时自身也是一个热点供其他WiFi设备来连接）
所有WiFi编程项目在使用WiFi前必须配置WiFi运行模式，否则无法使用WiFi。在这节实验课程中，我们将接着学习使用ESP32的WiFi AP模式。
**AP模式：**
接入点Access Point（AP）是一种提供 Wi-Fi 网络访问的设备，并将其连接到有线网络的装置。ESP32除了不具有与有线网络的接口外，还可以提供类似的功能。这种操作模式称为软接入点（soft-AP）。可以同时连接到soft-AP的最大站数可以设置4，默认为4。
当ESP32单独处于AP模式下时，可以被认为是一个无法访问外网的局域网WiFi路由器节点，它可以接受各类设备的连接请求。并可以和连接设备进行TCP、UDP连接，实现数据流。在局域物联网的设计中可以承担数据收发节点的作用。如下图所示，以ESP32为热点。如果手机或PC需要与ESP32通信，则必须连接到ESP32的热点。只有通过与ESP32建立连接后才能进行通信。
---
1.2 实验组件
|  |  |
| ------------------------ | --------------------- |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**WiFi_AP_Mode.ino**"。
在代码运行之前，需要配置ESP32的 AP名称和连接密码，如下图所示。当然，你也可以不修改它，使用默认的名称和连接密码。
```c++
/*
* 名称 : WiFi AP
* 功能 : 设置ESP32开启接入点
* 作者 : http://www.keyes-robot.com/
*/
#include //包括ESP32的WiFi Library头文件。
const char *ssid_AP = "ESP32_WiFi"; //输入路由器名称
const char *password_AP = "12345678"; //输入路由器密码
IPAddress local_IP(192,168,1,108);//配置ESP32自身的IP地址
IPAddress gateway(192,168,1,1); //设置ESP32本身的网关
IPAddress subnet(255,255,255,0); //设置ESP32自身的子网掩码
void setup(){
Serial.begin(115200);
delay(2000);
Serial.println("Setting soft-AP configuration ... ");
WiFi.disconnect();
WiFi.mode(WIFI_AP);
Serial.println(WiFi.softAPConfig(local_IP, gateway, subnet) ? "Ready" : "Failed!");
Serial.println("Setting soft-AP ... ");
boolean result = WiFi.softAP(ssid_AP, password_AP);
if(result){
Serial.println("Ready");
Serial.println(String("Soft-AP IP address = ") + WiFi.softAPIP().toString());
Serial.println(String("MAC address = ") + WiFi.softAPmacAddress().c_str());
}else{
Serial.println("Failed!");
}
Serial.println("Setup End");
}
void loop() {
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，打开串口监视器，设置波特率为**115200**，出现AP 以及 MAC 的IP地址。
**注意：如果打开串口监视器且设置好波特率，串口监视器窗口还是没有显示任何信息，可以尝试按下ESP32的RESET按键。**
打开手机的 WiFi 扫描功能，可以看到ESP32的 SSID ，在本课程代码中的名称为 “**ESP32_WiFi**” 。
你可以输入密码 “**12345678**” 连接它，也可以通过修改程序代码来修改它的AP名称和密码。
---
1.6 代码说明
| 代码 | 说明 |
| --------------------------------- | --------------------------- |
| IPAddress local_IP(192,168,1,108) | 配置ESP32自身的IP地址。 |
| IPAddress gateway(192,168,1,1) | 配置ESP32自身的网关IP地址。 |
| IPAddress subnet(255,255,255,0) | 设置ESP32自身的子网掩码。 |
| WiFi.mode(WIFI_AP) | 设置WIFI模式为AP模式。 |
---
### 第三十八课 WiFi Station+AP Mode
1.1 项目介绍
从第六十一课实验中我们知道ESP32有3种不同的WiFi工作模式：
- Station模式（作为WiFi设备主动连接路由器，也叫做WiFi Client）
- AP模式（作为一个Access Point，让其他WiFi设备来连接）即WiFi热点
- Station+AP共存模式（ESP32连接路由器的同时自身也是一个热点供其他WiFi设备来连接）
所有WiFi编程项目在使用WiFi前必须配置WiFi运行模式，否则无法使用WiFi。在这节实验课程中，我们将接着学习使用ESP32的WiFi Station+AP模式。
**AP+Station模式：**
ESP32除AP模式和Station模式外，还可以同时使用AP模式和Station模式。此模式包含前两种模式的功能。打开ESP32的Station模式，将其连接到路由器网络，它可以通过路由器与Internet通信。同时开启其AP模式，创建热点网络。其他WiFi设备可以选择连接路由器网络或热点网络与ESP32通信。
---
1.2 实验组件
|  |  |
| ------------------------ | --------------------- |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**WiFi_Station_AP_Mode.ino**"。
在代码运行之前，需要配置 WiFi 名称和密码、ESP32的 AP名称和连接密码，如下图所示。
```c++
/*
* 名称 : WiFi AP+Station
* 功能 : ESP32连接到用户的路由器，打开一个接入点
* 作者 : http://www.keyes-robot.com/
*/
#include
const char *ssid_Router = "ChinaNet_2.4G"; //输入路由器名称
const char *password_Router = "ChinaNet@233"; //输入路由器密码
const char *ssid_AP = "ESP32_WiFi";//输入路由器名称
const char *password_AP = "12345678"; //输入路由器密码
void setup(){
Serial.begin(115200);
Serial.println("Setting soft-AP configuration ... ");
WiFi.disconnect();
WiFi.mode(WIFI_AP);
Serial.println("Setting soft-AP ... ");
boolean result = WiFi.softAP(ssid_AP, password_AP);
if(result){
Serial.println("Ready");
Serial.println(String("Soft-AP IP address = ") + WiFi.softAPIP().toString());
Serial.println(String("MAC address = ") + WiFi.softAPmacAddress().c_str());
}else{
Serial.println("Failed!");
}
Serial.println("\nSetting Station configuration ... ");
WiFi.begin(ssid_Router, password_Router);
Serial.println(String("Connecting to ")+ ssid_Router);
while (WiFi.status() != WL_CONNECTED){
delay(500);
Serial.print(".");
}
Serial.println("\nConnected, IP address: ");
Serial.println(WiFi.localIP());
Serial.println("Setup End");
}
void loop() {
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
代码上传成功后，打开串口监视器，设置波特率为**115200**。
**注意：如果打开串口监视器且设置好波特率，串口监视器窗口还是没有显示任何信息，可以尝试按下ESP32的RESET按键。**
打开手机 WiFi 扫描功能，可以看到ESP32的SSID，名称为 “**ESP32_WiFi**” 。
---
1.6 代码说明
此课程代码与第三十六课和第三十七课代码类似，这里就不多做介绍了。
---
### 第三十九课 综合实验
1.1 项目介绍
我们已经学习了所有的模块和传感器的使用方法，也学习了将它们搭配在一起组合实验。在这一实验课程中我们将搭配更多的模块和传感器组合在一起。参考前面实验编程的方法，利用按键模块，实现每按一次按键，功能就变换一次的效果。
实验多种多样，大家可以发挥想象力，搭配模块和传感器做出更多具有意义的实验。
---
1.2 实验组件
|  |  |  |  |
| ---------------------------- | ------------------------ | ---------------------------- | ---------------------------- |
| ESP32 Plus主板 x1 | Keyes 紫色LED模块 x1 | Keyes 单路按键模块 x1 | Keyes 旋转电位器模块 x1 |
|  |  |  |  |
| Keyes 避障传感器 x1 | Keyes 摇杆模块 x1 | HC-SR04 超声波传感器 x1 | Keyes 超声波转接模块 x1 |
|  |  |  |  |
| Keyes 共阴RGB模块 x1 | Keyes 白色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x4 | XH2.54-4P 转杜邦线母单线 x2 |
|  | | | |
| XH2.54-5P 转杜邦线母单线 x1 | | | |
---
1.3 模块接线图
---
1.4 实验代码
本项目中使用的代码保存在文件夹“**\Arduino\Arduino_C_代码**”中，我们可以在此路径下打开代码文件''**Comprehensive_experiment.ino**"。
**注意：为了避免上传代码不成功，请上传代码前不要连接模块。代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，观察实验结果。**
```c++
/*
* 名称 : Comprehensive experiment
* 功能 : 多个传感器/模块协同工作
* 作者 : http://www.keyes-robot.com/
*/
//RGB连接到2,4,32
int ledPins[] = {2, 4, 32}; //定义红色，绿色，蓝色引脚
const byte chns[] = {0, 1, 2}; //定义PWM通道
int red, green, blue;
//摇臂模块接口
int xyzPins[] = {33, 34, 18}; //x, y, z
//电位器引脚连接到端口35
int resPin = 35;
//避障传感器引脚连接到IO端口14
int Avoid = 14;
//LED连接到GP5
#define PIN_LED 5 // LED的引脚
#define CHAN 3 // ledc 3
//超声波传感器接口
int Trig = 13;
int Echo = 12;
//关键模块端口
int button = 23;
int PushCounter = 0;//存储键被按下的次数
int yushu = 0;
unsigned char dht[4] = {0, 0, 0, 0};//只接收数据的前32位，不接收奇偶校验位
bool ir_flag = 1;
float out_X, out_Y, out_Z;
void counter() {
delay(10);
ir_flag = 0;
if (!digitalRead(button)) {
PushCounter++;
}
}
void setup() {
Serial.begin(9600);//波特率设置为9600
pinMode(xyzPins[0], INPUT); //x axis.
pinMode(xyzPins[1], INPUT); //y axis.
pinMode(xyzPins[2], INPUT_PULLUP); //Z轴是一个按钮
ledcSetup(CHAN, 1000, 12);
ledcAttachPin(PIN_LED, CHAN);
pinMode(button, INPUT);//关键模块
attachInterrupt(digitalPinToInterrupt(button), counter, FALLING); //外部中断0，下降沿触发
pinMode(Avoid, INPUT);//避障传感器
pinMode(Trig, OUTPUT);//超声波警报器
pinMode(Echo, INPUT);
for (int i = 0; i < 3; i++) { //设置pwm通道，1KHz,8bit
ledcSetup(chns[i], 1000, 8);
ledcAttachPin(ledPins[i], chns[i]);
delay(1000);
}
}
void loop() {
yushu = PushCounter % 5;
if (yushu == 0) { //余数为0
yushu_0(); //rgb显示
} else if (yushu == 1) { //余数是1
yushu_1(); //避障传感器检测障碍物
} else if (yushu == 2) { //余数是2
yushu_2(); //显示摇杆值
} else if (yushu == 3) { //余数是3
yushu_3(); //显示电位器ADC值和电位器控制LED
} else if (yushu == 4) { //余数是4
yushu_4(); //显示超声波检测到的距离
}
}
//RGB
void yushu_0() {
red = random(0, 256);
green = random(0, 256);
blue = random(0, 256);
setColor(red, green, blue);
delay(200);
}
void setColor(byte r, byte g, byte b) {
ledcWrite(chns[0], 255 - r);
ledcWrite(chns[1], 255 - g);
ledcWrite(chns[2], 255 - b);
}
void yushu_1() {
int val = digitalRead(Avoid);//读取避障传感器的数字电平输出
Serial.print(val);//串口打印值
if (val == 0) {//障碍物检测
Serial.println(" There are obstacles");
}
else {//未发现障碍物
Serial.println(" All going well");
}
delay(100);
}
void yushu_2() {
int xVal = analogRead(xyzPins[0]);
int yVal = analogRead(xyzPins[1]);
int zVal = digitalRead(xyzPins[2]);
Serial.println("X,Y,Z: " + String(xVal) + ", " + String(yVal) + ", " + String(zVal));
delay(500);
}
void yushu_3() {
int adcVal = analogRead(resPin); //读adc
Serial.println(adcVal);
int pwmVal = adcVal; //adcVal重新映射到pwmVal
ledcWrite(CHAN, pwmVal); //设置累计脉冲宽度
delay(100);
}
void yushu_4() {
float distance = checkdistance();
Serial.print("distance:");
Serial.print(distance);
Serial.println("cm");
delay(100);
}
float checkdistance() {
digitalWrite(Trig, LOW);
delayMicroseconds(2);
digitalWrite(Trig, HIGH);
delayMicroseconds(10);
digitalWrite(Trig, LOW);
float distance = pulseIn(Echo, HIGH) / 58.00;
delay(10);
return distance;
}
```
ESP32主板通过USB线连接到计算机后开始上传代码。为了避免将代码上传至ESP32主板时出现错误，必须选择与计算机连接正确的控制板和串行端口。
点击“**工具**”→“**开发板**”，可以查看到各种不同型号ESP32开发板，选择对应的ESP32开发板型号。
点击“**工具**”→“**端口**”，选择对应的串行端口。
**注意：将ESP32主板通过USB线连接到计算机后才能看到对应的串行端口**。
单击将代码上传到ESP32主控板，等待代码上传成功后查看实验结果。
---
1.5 实验结果
**注意：Arduino IDE 2.1.1 以上版本可能出现串口监视器乱码的情况，建议使用本教程推荐的版本或 2.1.1 以下版本。**
代码上传成功后，拔下USB线断电，按照接线图正确接好模块后再用USB线连接到计算机上电，打开串口监视器，设置波特率为**9600**。
（1）初始时没有按下按键，按键次数为 0 ，余数为 0 ，RGB模块循环闪烁随机颜色。
（2）按一下按键（时间稍长以便能检测到按键按下），RGB LED灯停止闪烁。此时按键次数为 1 ，余数为 1 ，实验实现避障传感器检测障碍物并读取高低电平的功能。
当传感器没有检测到障碍物时，val为**1**，串口监视器打印出 “**1 All going well**” ，灯 SLED **不亮**；
当传感器检测到障碍物时，val为**0**，串口监视器打印出 “**0 There are obstacles**” ，灯 SLED **亮**。
**注意：如果在打开串口监视器之前先按下按键，按键次数变为1。再打开串口监视器时程序会复位，按键成次数会变为0，需要再次按下按键重新设置按键次数为1。**
（3）再按一下按键，按键次数为 2 ，余数为 2 。实验实现读取当前摇杆X轴和Y轴对应的模拟值以及Z轴（B接口）对应的数字值的功能。串口监视器打印出当前摇杆X轴、Y轴和Z轴对应的值。
（4）再按一下按键，按键次数为 3 ，余数为 3 。实验实现利用可调电位器模块调节 LED（GPIO5）接口输出的PWM值，从而实现调节LED模块上LED亮度的功能。串口监视器打印出当前输出的模拟值。
（5）再按一下按键，按键次数为 4 ，余数为 4 。实验实现的功能是利用超声波模块检测距离并在串口打印出来，串口监视器显示图如下。
（6）再按一下按键，按键次数为 5 ，余数为 0 。实现初始时RGB循环闪烁随机颜色的效果。不断地按下按键，余数循环变化，实验功能也循环变化。
---